diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7413dc33272..e3c693e0dcf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,6 +16,7 @@ permissions:
 jobs:
   test-build:
     name: Test and Build
+    if: github.ref != 'refs/heads/dev' || github.event_name == 'pull_request'
     uses: ./.github/workflows/test-build.yml
     secrets: inherit
 
@@ -45,11 +46,66 @@ jobs:
             echo "ℹ️ Not a release commit"
           fi
 
-  # Build AMD64 images and push to ECR immediately (+ GHCR for main)
+  # Dev: build all 3 images for ECR only (no GHCR, no ARM64)
+  build-dev:
+    name: Build Dev ECR
+    needs: [detect-version]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
+    runs-on: blacksmith-8vcpu-ubuntu-2404
+    permissions:
+      contents: read
+      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - dockerfile: ./docker/app.Dockerfile
+            ecr_repo_secret: ECR_APP
+          - dockerfile: ./docker/db.Dockerfile
+            ecr_repo_secret: ECR_MIGRATIONS
+          - dockerfile: ./docker/realtime.Dockerfile
+            ecr_repo_secret: ECR_REALTIME
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          role-to-assume: ${{ secrets.DEV_AWS_ROLE_TO_ASSUME }}
+          aws-region: ${{ secrets.DEV_AWS_REGION }}
+
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: useblacksmith/setup-docker-builder@v1
+
+      - name: Build and push
+        uses: useblacksmith/build-push-action@v2
+        with:
+          context: .
+          file: ${{ matrix.dockerfile }}
+          platforms: linux/amd64
+          push: true
+          tags: ${{ steps.login-ecr.outputs.registry }}/${{ secrets[matrix.ecr_repo_secret] }}:dev
+          provenance: false
+          sbom: false
+
+  # Main/staging: build AMD64 images and push to ECR + GHCR
   build-amd64:
     name: Build AMD64
-    needs: [detect-version]
-    if: github.event_name == 'push' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging' || github.ref == 'refs/heads/dev')
+    needs: [test-build, detect-version]
+    if: >-
+      github.event_name == 'push' &&
+      (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/staging')
     runs-on: blacksmith-8vcpu-ubuntu-2404
     permissions:
       contents: read
@@ -75,8 +131,8 @@ jobs:
       - name: Configure AWS credentials
         uses: aws-actions/configure-aws-credentials@v4
         with:
-          role-to-assume: ${{ github.ref == 'refs/heads/main' && secrets.AWS_ROLE_TO_ASSUME || github.ref == 'refs/heads/dev' && secrets.DEV_AWS_ROLE_TO_ASSUME || secrets.STAGING_AWS_ROLE_TO_ASSUME }}
-          aws-region: ${{ github.ref == 'refs/heads/main' && secrets.AWS_REGION || github.ref == 'refs/heads/dev' && secrets.DEV_AWS_REGION || secrets.STAGING_AWS_REGION }}
+          role-to-assume: ${{ github.ref == 'refs/heads/main' && secrets.AWS_ROLE_TO_ASSUME || secrets.STAGING_AWS_ROLE_TO_ASSUME }}
+          aws-region: ${{ github.ref == 'refs/heads/main' && secrets.AWS_REGION || secrets.STAGING_AWS_REGION }}
 
       - name: Login to Amazon ECR
         id: login-ecr
@@ -106,26 +162,20 @@ jobs:
           ECR_REPO="${{ secrets[matrix.ecr_repo_secret] }}"
           GHCR_IMAGE="${{ matrix.ghcr_image }}"
 
-          # ECR tags (always build for ECR)
           if [ "${{ github.ref }}" = "refs/heads/main" ]; then
             ECR_TAG="latest"
-          elif [ "${{ github.ref }}" = "refs/heads/dev" ]; then
-            ECR_TAG="dev"
           else
             ECR_TAG="staging"
           fi
           ECR_IMAGE="${ECR_REGISTRY}/${ECR_REPO}:${ECR_TAG}"
 
-          # Build tags list
           TAGS="${ECR_IMAGE}"
 
-          # Add GHCR tags only for main branch
           if [ "${{ github.ref }}" = "refs/heads/main" ]; then
             GHCR_AMD64="${GHCR_IMAGE}:latest-amd64"
             GHCR_SHA="${GHCR_IMAGE}:${{ github.sha }}-amd64"
             TAGS="${TAGS},$GHCR_AMD64,$GHCR_SHA"
 
-            # Add version tag if this is a release commit
             if [ "${{ needs.detect-version.outputs.is_release }}" = "true" ]; then
               VERSION="${{ needs.detect-version.outputs.version }}"
               GHCR_VERSION="${GHCR_IMAGE}:${VERSION}-amd64"
@@ -256,6 +306,14 @@ jobs:
             docker manifest push "${IMAGE_BASE}:${VERSION}"
           fi
 
+  # Run database migrations for dev
+  migrate-dev:
+    name: Migrate Dev DB
+    needs: [build-dev]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
+    uses: ./.github/workflows/migrations.yml
+    secrets: inherit
+
   # Check if docs changed
   check-docs-changes:
     name: Check Docs Changes
diff --git a/.github/workflows/migrations.yml b/.github/workflows/migrations.yml
index db084926861..245023ab86f 100644
--- a/.github/workflows/migrations.yml
+++ b/.github/workflows/migrations.yml
@@ -38,5 +38,5 @@ jobs:
       - name: Apply migrations
         working-directory: ./packages/db
         env:
-          DATABASE_URL: ${{ github.ref == 'refs/heads/main' && secrets.DATABASE_URL || secrets.STAGING_DATABASE_URL }}
+          DATABASE_URL: ${{ github.ref == 'refs/heads/main' && secrets.DATABASE_URL || github.ref == 'refs/heads/dev' && secrets.DEV_DATABASE_URL || secrets.STAGING_DATABASE_URL }}
         run: bunx drizzle-kit migrate --config=./drizzle.config.ts
\ No newline at end of file
diff --git a/README.md b/README.md
index 93dbc8ba00e..de6befd2a8f 100644
--- a/README.md
+++ b/README.md
@@ -74,10 +74,6 @@ docker compose -f docker-compose.prod.yml up -d
 
 Open [http://localhost:3000](http://localhost:3000)
 
-#### Background worker note
-
-The Docker Compose stack starts a dedicated worker container by default. If `REDIS_URL` is not configured, the worker will start, log that it is idle, and do no queue processing. This is expected. Queue-backed API, webhook, and schedule execution requires Redis; installs without Redis continue to use the inline execution path.
-
 Sim also supports local models via [Ollama](https://ollama.ai) and [vLLM](https://docs.vllm.ai/) — see the [Docker self-hosting docs](https://docs.sim.ai/self-hosting/docker) for setup details.
 
 ### Self-hosted: Manual Setup
@@ -123,12 +119,10 @@ cd packages/db && bun run db:migrate
 5. Start development servers:
 
 ```bash
-bun run dev:full  # Starts Next.js app, realtime socket server, and the BullMQ worker
+bun run dev:full  # Starts Next.js app and realtime socket server
 ```
 
-If `REDIS_URL` is not configured, the worker will remain idle and execution continues inline.
-
-Or run separately: `bun run dev` (Next.js), `cd apps/sim && bun run dev:sockets` (realtime), and `cd apps/sim && bun run worker` (BullMQ worker).
+Or run separately: `bun run dev` (Next.js) and `cd apps/sim && bun run dev:sockets` (realtime).
 
 ## Copilot API Keys
 
diff --git a/apps/sim/app/(landing)/components/features/components/features-preview.tsx b/apps/sim/app/(landing)/components/features/components/features-preview.tsx
index e485396a7e6..ae603009bc5 100644
--- a/apps/sim/app/(landing)/components/features/components/features-preview.tsx
+++ b/apps/sim/app/(landing)/components/features/components/features-preview.tsx
@@ -2,8 +2,8 @@
 
 import { type SVGProps, useEffect, useRef, useState } from 'react'
 import { AnimatePresence, motion, useInView } from 'framer-motion'
-import ReactMarkdown, { type Components } from 'react-markdown'
-import remarkGfm from 'remark-gfm'
+import { Streamdown } from 'streamdown'
+import 'streamdown/styles.css'
 import { ChevronDown } from '@/components/emcn'
 import { Database, File, Library, Table } from '@/components/emcn/icons'
 import {
@@ -557,8 +557,8 @@ The team agreed to prioritize the new onboarding flow. Key decisions:
 
 Follow up with engineering on the timeline for the API v2 migration. Draft the proposal for the board meeting next week.`
 
-const MD_COMPONENTS: Components = {
-  h1: ({ children }) => (
+const MD_COMPONENTS = {
+  h1: ({ children }: { children?: React.ReactNode }) => (
     <p
       role='presentation'
       className='mb-4 border-[#E5E5E5] border-b pb-2 font-semibold text-[#1C1C1C] text-[20px]'
@@ -566,17 +566,23 @@ const MD_COMPONENTS: Components = {
       {children}
     </p>
   ),
-  h2: ({ children }) => (
+  h2: ({ children }: { children?: React.ReactNode }) => (
     <h2 className='mt-5 mb-3 border-[#E5E5E5] border-b pb-1.5 font-semibold text-[#1C1C1C] text-[16px]'>
       {children}
     </h2>
   ),
-  ul: ({ children }) => <ul className='mb-3 list-disc pl-6'>{children}</ul>,
-  ol: ({ children }) => <ol className='mb-3 list-decimal pl-6'>{children}</ol>,
-  li: ({ children }) => (
+  ul: ({ children }: { children?: React.ReactNode }) => (
+    <ul className='mb-3 list-disc pl-6'>{children}</ul>
+  ),
+  ol: ({ children }: { children?: React.ReactNode }) => (
+    <ol className='mb-3 list-decimal pl-6'>{children}</ol>
+  ),
+  li: ({ children }: { children?: React.ReactNode }) => (
     <li className='mb-1 text-[#1C1C1C] text-[14px] leading-[1.6]'>{children}</li>
   ),
-  p: ({ children }) => <p className='mb-3 text-[#1C1C1C] text-[14px] leading-[1.6]'>{children}</p>,
+  p: ({ children }: { children?: React.ReactNode }) => (
+    <p className='mb-3 text-[#1C1C1C] text-[14px] leading-[1.6]'>{children}</p>
+  ),
 }
 
 function MockFullFiles() {
@@ -618,9 +624,9 @@ function MockFullFiles() {
           transition={{ duration: 0.4, delay: 0.5 }}
         >
           <div className='h-full overflow-auto p-6'>
-            <ReactMarkdown remarkPlugins={[remarkGfm]} components={MD_COMPONENTS}>
+            <Streamdown mode='static' components={MD_COMPONENTS}>
               {source}
-            </ReactMarkdown>
+            </Streamdown>
           </div>
         </motion.div>
       </div>
diff --git a/apps/sim/app/api/admin/mothership/route.ts b/apps/sim/app/api/admin/mothership/route.ts
new file mode 100644
index 00000000000..c298370ed39
--- /dev/null
+++ b/apps/sim/app/api/admin/mothership/route.ts
@@ -0,0 +1,144 @@
+import { db } from '@sim/db'
+import { user } from '@sim/db/schema'
+import { eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { env } from '@/lib/core/config/env'
+
+const ENV_URLS: Record<string, string | undefined> = {
+  dev: env.MOTHERSHIP_DEV_URL,
+  staging: env.MOTHERSHIP_STAGING_URL,
+  prod: env.MOTHERSHIP_PROD_URL,
+}
+
+function getMothershipUrl(environment: string): string | null {
+  return ENV_URLS[environment] ?? null
+}
+
+async function isAdminRequestAuthorized() {
+  const session = await getSession()
+  if (!session?.user?.id) return false
+
+  const [currentUser] = await db
+    .select({ role: user.role })
+    .from(user)
+    .where(eq(user.id, session.user.id))
+    .limit(1)
+
+  return currentUser?.role === 'admin'
+}
+
+/**
+ * Proxy to the mothership admin API.
+ *
+ * Query params:
+ *   env       - "dev" | "staging" | "prod"
+ *   endpoint  - the admin endpoint path, e.g. "requests", "licenses", "traces"
+ *
+ * The request body (for POST) is forwarded as-is. Additional query params
+ * (e.g. requestId for GET /traces) are forwarded.
+ */
+export async function POST(req: NextRequest) {
+  if (!(await isAdminRequestAuthorized())) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const adminKey = env.MOTHERSHIP_API_ADMIN_KEY
+  if (!adminKey) {
+    return NextResponse.json({ error: 'MOTHERSHIP_API_ADMIN_KEY not configured' }, { status: 500 })
+  }
+
+  const { searchParams } = new URL(req.url)
+  const environment = searchParams.get('env') || 'dev'
+  const endpoint = searchParams.get('endpoint')
+
+  if (!endpoint) {
+    return NextResponse.json({ error: 'endpoint query param required' }, { status: 400 })
+  }
+
+  const baseUrl = getMothershipUrl(environment)
+  if (!baseUrl) {
+    return NextResponse.json(
+      { error: `No URL configured for environment: ${environment}` },
+      { status: 400 }
+    )
+  }
+
+  const targetUrl = `${baseUrl}/api/admin/${endpoint}`
+
+  try {
+    const body = await req.text()
+    const upstream = await fetch(targetUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': adminKey,
+      },
+      ...(body ? { body } : {}),
+    })
+
+    const data = await upstream.json()
+    return NextResponse.json(data, { status: upstream.status })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error: `Failed to reach mothership (${environment}): ${error instanceof Error ? error.message : 'Unknown error'}`,
+      },
+      { status: 502 }
+    )
+  }
+}
+
+export async function GET(req: NextRequest) {
+  if (!(await isAdminRequestAuthorized())) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const adminKey = env.MOTHERSHIP_API_ADMIN_KEY
+  if (!adminKey) {
+    return NextResponse.json({ error: 'MOTHERSHIP_API_ADMIN_KEY not configured' }, { status: 500 })
+  }
+
+  const { searchParams } = new URL(req.url)
+  const environment = searchParams.get('env') || 'dev'
+  const endpoint = searchParams.get('endpoint')
+
+  if (!endpoint) {
+    return NextResponse.json({ error: 'endpoint query param required' }, { status: 400 })
+  }
+
+  const baseUrl = getMothershipUrl(environment)
+  if (!baseUrl) {
+    return NextResponse.json(
+      { error: `No URL configured for environment: ${environment}` },
+      { status: 400 }
+    )
+  }
+
+  const forwardParams = new URLSearchParams()
+  searchParams.forEach((value, key) => {
+    if (key !== 'env' && key !== 'endpoint') {
+      forwardParams.set(key, value)
+    }
+  })
+
+  const qs = forwardParams.toString()
+  const targetUrl = `${baseUrl}/api/admin/${endpoint}${qs ? `?${qs}` : ''}`
+
+  try {
+    const upstream = await fetch(targetUrl, {
+      method: 'GET',
+      headers: { 'x-api-key': adminKey },
+    })
+
+    const data = await upstream.json()
+    return NextResponse.json(data, { status: upstream.status })
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error: `Failed to reach mothership (${environment}): ${error instanceof Error ? error.message : 'Unknown error'}`,
+      },
+      { status: 502 }
+    )
+  }
+}
diff --git a/apps/sim/app/api/billing/update-cost/route.ts b/apps/sim/app/api/billing/update-cost/route.ts
index 65899d55572..743ddb17011 100644
--- a/apps/sim/app/api/billing/update-cost/route.ts
+++ b/apps/sim/app/api/billing/update-cost/route.ts
@@ -4,7 +4,7 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { recordUsage } from '@/lib/billing/core/usage-log'
 import { checkAndBillOverageThreshold } from '@/lib/billing/threshold-billing'
-import { checkInternalApiKey } from '@/lib/copilot/utils'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
 import { isBillingEnabled } from '@/lib/core/config/feature-flags'
 import { generateRequestId } from '@/lib/core/utils/request'
 
diff --git a/apps/sim/app/api/chat/route.test.ts b/apps/sim/app/api/chat/route.test.ts
index 47840515e98..88fbe2d22e1 100644
--- a/apps/sim/app/api/chat/route.test.ts
+++ b/apps/sim/app/api/chat/route.test.ts
@@ -274,6 +274,50 @@ describe('Chat API Route', () => {
       )
     })
 
+    it('passes chat customizations and outputConfigs through in the API request shape', async () => {
+      mockGetSession.mockResolvedValue({
+        user: { id: 'user-id', email: 'user@example.com' },
+      })
+
+      const validData = {
+        workflowId: 'workflow-123',
+        identifier: 'test-chat',
+        title: 'Test Chat',
+        customizations: {
+          primaryColor: '#000000',
+          welcomeMessage: 'Hello',
+          imageUrl: 'https://example.com/icon.png',
+        },
+        outputConfigs: [{ blockId: 'agent-1', path: 'content' }],
+      }
+
+      mockLimit.mockResolvedValueOnce([])
+      mockCheckWorkflowAccessForChatCreation.mockResolvedValue({
+        hasAccess: true,
+        workflow: { userId: 'user-id', workspaceId: null, isDeployed: true },
+      })
+
+      const req = new NextRequest('http://localhost:3000/api/chat', {
+        method: 'POST',
+        body: JSON.stringify(validData),
+      })
+      const response = await POST(req)
+
+      expect(response.status).toBe(200)
+      expect(mockPerformChatDeploy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          workflowId: 'workflow-123',
+          identifier: 'test-chat',
+          customizations: {
+            primaryColor: '#000000',
+            welcomeMessage: 'Hello',
+            imageUrl: 'https://example.com/icon.png',
+          },
+          outputConfigs: [{ blockId: 'agent-1', path: 'content' }],
+        })
+      )
+    })
+
     it('should allow chat deployment when user has workspace admin permission', async () => {
       mockGetSession.mockResolvedValue({
         user: { id: 'user-id', email: 'user@example.com' },
diff --git a/apps/sim/app/api/copilot/api-keys/validate/route.ts b/apps/sim/app/api/copilot/api-keys/validate/route.ts
index 77521f3b3ed..1c1df540132 100644
--- a/apps/sim/app/api/copilot/api-keys/validate/route.ts
+++ b/apps/sim/app/api/copilot/api-keys/validate/route.ts
@@ -1,8 +1,11 @@
+import { db } from '@sim/db'
+import { user } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { checkServerSideUsageLimits } from '@/lib/billing/calculations/usage-monitor'
-import { checkInternalApiKey } from '@/lib/copilot/utils'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
 
 const logger = createLogger('CopilotApiKeysValidate')
 
@@ -34,6 +37,12 @@ export async function POST(req: NextRequest) {
 
     const { userId } = validationResult.data
 
+    const [existingUser] = await db.select().from(user).where(eq(user.id, userId)).limit(1)
+    if (!existingUser) {
+      logger.warn('[API VALIDATION] userId does not exist', { userId })
+      return NextResponse.json({ error: 'User not found' }, { status: 403 })
+    }
+
     logger.info('[API VALIDATION] Validating usage limit', { userId })
 
     const { isExceeded, currentUsage, limit } = await checkServerSideUsageLimits(userId)
diff --git a/apps/sim/app/api/copilot/chat/abort/route.ts b/apps/sim/app/api/copilot/chat/abort/route.ts
index 33fe68c8d88..375065eb418 100644
--- a/apps/sim/app/api/copilot/chat/abort/route.ts
+++ b/apps/sim/app/api/copilot/chat/abort/route.ts
@@ -1,11 +1,14 @@
+import { createLogger } from '@sim/logger'
 import { NextResponse } from 'next/server'
 import { getLatestRunForStream } from '@/lib/copilot/async-runs/repository'
-import { abortActiveStream, waitForPendingChatStream } from '@/lib/copilot/chat-streaming'
 import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
+import { abortActiveStream, waitForPendingChatStream } from '@/lib/copilot/request/session'
 import { env } from '@/lib/core/config/env'
 
+const logger = createLogger('CopilotChatAbortAPI')
 const GO_EXPLICIT_ABORT_TIMEOUT_MS = 3000
+const STREAM_ABORT_SETTLE_TIMEOUT_MS = 8000
 
 export async function POST(request: Request) {
   const { userId: authenticatedUserId, isAuthenticated } =
@@ -15,7 +18,12 @@ export async function POST(request: Request) {
     return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
   }
 
-  const body = await request.json().catch(() => ({}))
+  const body = await request.json().catch((err) => {
+    logger.warn('Abort request body parse failed; continuing with empty object', {
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return {}
+  })
   const streamId = typeof body.streamId === 'string' ? body.streamId : ''
   let chatId = typeof body.chatId === 'string' ? body.chatId : ''
 
@@ -24,7 +32,13 @@ export async function POST(request: Request) {
   }
 
   if (!chatId) {
-    const run = await getLatestRunForStream(streamId, authenticatedUserId).catch(() => null)
+    const run = await getLatestRunForStream(streamId, authenticatedUserId).catch((err) => {
+      logger.warn('getLatestRunForStream failed while resolving chatId for abort', {
+        streamId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return null
+    })
     if (run?.chatId) {
       chatId = run.chatId
     }
@@ -36,7 +50,10 @@ export async function POST(request: Request) {
       headers['x-api-key'] = env.COPILOT_API_KEY
     }
     const controller = new AbortController()
-    const timeout = setTimeout(() => controller.abort(), GO_EXPLICIT_ABORT_TIMEOUT_MS)
+    const timeout = setTimeout(
+      () => controller.abort('timeout:go_explicit_abort_fetch'),
+      GO_EXPLICIT_ABORT_TIMEOUT_MS
+    )
     const response = await fetch(`${SIM_AGENT_API_URL}/api/streams/explicit-abort`, {
       method: 'POST',
       headers,
@@ -50,15 +67,24 @@ export async function POST(request: Request) {
     if (!response.ok) {
       throw new Error(`Explicit abort marker request failed: ${response.status}`)
     }
-  } catch {
-    // best effort: local abort should still proceed even if Go marker fails
+  } catch (err) {
+    logger.warn('Explicit abort marker request failed; proceeding with local abort', {
+      streamId,
+      error: err instanceof Error ? err.message : String(err),
+    })
   }
 
   const aborted = await abortActiveStream(streamId)
   if (chatId) {
-    await waitForPendingChatStream(chatId, GO_EXPLICIT_ABORT_TIMEOUT_MS + 1000, streamId).catch(
-      () => false
-    )
+    const settled = await waitForPendingChatStream(chatId, STREAM_ABORT_SETTLE_TIMEOUT_MS, streamId)
+    if (!settled) {
+      return NextResponse.json(
+        { error: 'Previous response is still shutting down', aborted, settled: false },
+        { status: 409 }
+      )
+    }
+    return NextResponse.json({ aborted, settled: true })
   }
+
   return NextResponse.json({ aborted })
 }
diff --git a/apps/sim/app/api/copilot/chat/delete/route.test.ts b/apps/sim/app/api/copilot/chat/delete/route.test.ts
index c53c2a11256..0493b3ffe89 100644
--- a/apps/sim/app/api/copilot/chat/delete/route.test.ts
+++ b/apps/sim/app/api/copilot/chat/delete/route.test.ts
@@ -36,11 +36,11 @@ vi.mock('drizzle-orm', () => ({
   eq: vi.fn((field: unknown, value: unknown) => ({ field, value, type: 'eq' })),
 }))
 
-vi.mock('@/lib/copilot/chat-lifecycle', () => ({
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
   getAccessibleCopilotChat: mockGetAccessibleCopilotChat,
 }))
 
-vi.mock('@/lib/copilot/task-events', () => ({
+vi.mock('@/lib/copilot/tasks', () => ({
   taskPubSub: { publishStatusChanged: vi.fn() },
 }))
 
diff --git a/apps/sim/app/api/copilot/chat/delete/route.ts b/apps/sim/app/api/copilot/chat/delete/route.ts
index 652f732e676..1742d9e7e55 100644
--- a/apps/sim/app/api/copilot/chat/delete/route.ts
+++ b/apps/sim/app/api/copilot/chat/delete/route.ts
@@ -5,8 +5,8 @@ import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { getSession } from '@/lib/auth'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
-import { taskPubSub } from '@/lib/copilot/task-events'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import { taskPubSub } from '@/lib/copilot/tasks'
 
 const logger = createLogger('DeleteChatAPI')
 
diff --git a/apps/sim/app/api/copilot/chat/queries.ts b/apps/sim/app/api/copilot/chat/queries.ts
new file mode 100644
index 00000000000..4828a15aa75
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/queries.ts
@@ -0,0 +1,175 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, desc, eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getLatestRunForStream } from '@/lib/copilot/async-runs/repository'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import {
+  authenticateCopilotRequestSessionOnly,
+  createBadRequestResponse,
+  createInternalServerErrorResponse,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request/http'
+import { readFilePreviewSessions } from '@/lib/copilot/request/session'
+import { readEvents } from '@/lib/copilot/request/session/buffer'
+import { toStreamBatchEvent } from '@/lib/copilot/request/session/types'
+import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
+import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('CopilotChatAPI')
+
+function transformChat(chat: {
+  id: string
+  title: string | null
+  model: string | null
+  messages: unknown
+  planArtifact?: unknown
+  config?: unknown
+  conversationId?: string | null
+  resources?: unknown
+  createdAt: Date | null
+  updatedAt: Date | null
+}) {
+  return {
+    id: chat.id,
+    title: chat.title,
+    model: chat.model,
+    messages: Array.isArray(chat.messages) ? chat.messages : [],
+    messageCount: Array.isArray(chat.messages) ? chat.messages.length : 0,
+    planArtifact: chat.planArtifact || null,
+    config: chat.config || null,
+    ...('conversationId' in chat ? { activeStreamId: chat.conversationId || null } : {}),
+    ...('resources' in chat
+      ? { resources: Array.isArray(chat.resources) ? chat.resources : [] }
+      : {}),
+    createdAt: chat.createdAt,
+    updatedAt: chat.updatedAt,
+  }
+}
+
+export async function GET(req: NextRequest) {
+  try {
+    const { searchParams } = new URL(req.url)
+    const workflowId = searchParams.get('workflowId')
+    const workspaceId = searchParams.get('workspaceId')
+    const chatId = searchParams.get('chatId')
+
+    const { userId: authenticatedUserId, isAuthenticated } =
+      await authenticateCopilotRequestSessionOnly()
+    if (!isAuthenticated || !authenticatedUserId) {
+      return createUnauthorizedResponse()
+    }
+
+    if (chatId) {
+      const chat = await getAccessibleCopilotChat(chatId, authenticatedUserId)
+      if (!chat) {
+        return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
+      }
+
+      let streamSnapshot: {
+        events: ReturnType<typeof toStreamBatchEvent>[]
+        previewSessions: Awaited<ReturnType<typeof readFilePreviewSessions>>
+        status: string
+      } | null = null
+      if (chat.conversationId) {
+        try {
+          const [events, previewSessions, run] = await Promise.all([
+            readEvents(chat.conversationId, '0'),
+            readFilePreviewSessions(chat.conversationId).catch((error) => {
+              logger.warn('Failed to read preview sessions for copilot chat', {
+                chatId,
+                conversationId: chat.conversationId,
+                error: error instanceof Error ? error.message : String(error),
+              })
+              return []
+            }),
+            getLatestRunForStream(chat.conversationId, authenticatedUserId).catch((error) => {
+              logger.warn('Failed to fetch latest run for copilot chat snapshot', {
+                chatId,
+                conversationId: chat.conversationId,
+                error: error instanceof Error ? error.message : String(error),
+              })
+              return null
+            }),
+          ])
+
+          streamSnapshot = {
+            events: events.map(toStreamBatchEvent),
+            previewSessions,
+            status:
+              typeof run?.status === 'string'
+                ? run.status
+                : events.length > 0
+                  ? 'active'
+                  : 'unknown',
+          }
+        } catch (error) {
+          logger.warn('Failed to load copilot chat stream snapshot', {
+            chatId,
+            conversationId: chat.conversationId,
+            error: error instanceof Error ? error.message : String(error),
+          })
+        }
+      }
+
+      logger.info(`Retrieved chat ${chatId}`)
+      return NextResponse.json({
+        success: true,
+        chat: {
+          ...transformChat(chat),
+          ...(streamSnapshot ? { streamSnapshot } : {}),
+        },
+      })
+    }
+
+    if (!workflowId && !workspaceId) {
+      return createBadRequestResponse('workflowId, workspaceId, or chatId is required')
+    }
+
+    if (workspaceId) {
+      await assertActiveWorkspaceAccess(workspaceId, authenticatedUserId)
+    }
+
+    if (workflowId) {
+      const authorization = await authorizeWorkflowByWorkspacePermission({
+        workflowId,
+        userId: authenticatedUserId,
+        action: 'read',
+      })
+      if (!authorization.allowed) {
+        return createUnauthorizedResponse()
+      }
+    }
+
+    const scopeFilter = workflowId
+      ? eq(copilotChats.workflowId, workflowId)
+      : eq(copilotChats.workspaceId, workspaceId!)
+
+    const chats = await db
+      .select({
+        id: copilotChats.id,
+        title: copilotChats.title,
+        model: copilotChats.model,
+        messages: copilotChats.messages,
+        planArtifact: copilotChats.planArtifact,
+        config: copilotChats.config,
+        createdAt: copilotChats.createdAt,
+        updatedAt: copilotChats.updatedAt,
+      })
+      .from(copilotChats)
+      .where(and(eq(copilotChats.userId, authenticatedUserId), scopeFilter))
+      .orderBy(desc(copilotChats.updatedAt))
+
+    const scope = workflowId ? `workflow ${workflowId}` : `workspace ${workspaceId}`
+    logger.info(`Retrieved ${chats.length} chats for ${scope}`)
+
+    return NextResponse.json({
+      success: true,
+      chats: chats.map(transformChat),
+    })
+  } catch (error) {
+    logger.error('Error fetching copilot chats:', error)
+    return createInternalServerErrorResponse('Failed to fetch chats')
+  }
+}
diff --git a/apps/sim/app/api/copilot/chat/rename/route.ts b/apps/sim/app/api/copilot/chat/rename/route.ts
new file mode 100644
index 00000000000..7587f577411
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/rename/route.ts
@@ -0,0 +1,65 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { getSession } from '@/lib/auth'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import { taskPubSub } from '@/lib/copilot/tasks'
+
+const logger = createLogger('RenameChatAPI')
+
+const RenameChatSchema = z.object({
+  chatId: z.string().min(1),
+  title: z.string().min(1).max(200),
+})
+
+export async function PATCH(request: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await request.json()
+    const { chatId, title } = RenameChatSchema.parse(body)
+
+    const chat = await getAccessibleCopilotChat(chatId, session.user.id)
+    if (!chat) {
+      return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
+    }
+
+    const now = new Date()
+    const [updated] = await db
+      .update(copilotChats)
+      .set({ title, updatedAt: now, lastSeenAt: now })
+      .where(and(eq(copilotChats.id, chatId), eq(copilotChats.userId, session.user.id)))
+      .returning({ id: copilotChats.id, workspaceId: copilotChats.workspaceId })
+
+    if (!updated) {
+      return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
+    }
+
+    logger.info('Chat renamed', { chatId, title })
+
+    if (updated.workspaceId) {
+      taskPubSub?.publishStatusChanged({
+        workspaceId: updated.workspaceId,
+        chatId,
+        type: 'renamed',
+      })
+    }
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { success: false, error: 'Invalid request data', details: error.errors },
+        { status: 400 }
+      )
+    }
+    logger.error('Error renaming chat:', error)
+    return NextResponse.json({ success: false, error: 'Failed to rename chat' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/copilot/chat/resources/route.ts b/apps/sim/app/api/copilot/chat/resources/route.ts
index 8d528150218..f6042138c5e 100644
--- a/apps/sim/app/api/copilot/chat/resources/route.ts
+++ b/apps/sim/app/api/copilot/chat/resources/route.ts
@@ -10,8 +10,8 @@ import {
   createInternalServerErrorResponse,
   createNotFoundResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import type { ChatResource, ResourceType } from '@/lib/copilot/resources'
+} from '@/lib/copilot/request/http'
+import type { ChatResource, ResourceType } from '@/lib/copilot/resources/persistence'
 
 const logger = createLogger('CopilotChatResourcesAPI')
 
@@ -21,13 +21,14 @@ const VALID_RESOURCE_TYPES = new Set<ResourceType>([
   'workflow',
   'knowledgebase',
   'folder',
+  'log',
 ])
-const GENERIC_TITLES = new Set(['Table', 'File', 'Workflow', 'Knowledge Base', 'Folder'])
+const GENERIC_TITLES = new Set(['Table', 'File', 'Workflow', 'Knowledge Base', 'Folder', 'Log'])
 
 const AddResourceSchema = z.object({
   chatId: z.string(),
   resource: z.object({
-    type: z.enum(['table', 'file', 'workflow', 'knowledgebase', 'folder']),
+    type: z.enum(['table', 'file', 'workflow', 'knowledgebase', 'folder', 'log']),
     id: z.string(),
     title: z.string(),
   }),
@@ -35,7 +36,7 @@ const AddResourceSchema = z.object({
 
 const RemoveResourceSchema = z.object({
   chatId: z.string(),
-  resourceType: z.enum(['table', 'file', 'workflow', 'knowledgebase', 'folder']),
+  resourceType: z.enum(['table', 'file', 'workflow', 'knowledgebase', 'folder', 'log']),
   resourceId: z.string(),
 })
 
@@ -43,7 +44,7 @@ const ReorderResourcesSchema = z.object({
   chatId: z.string(),
   resources: z.array(
     z.object({
-      type: z.enum(['table', 'file', 'workflow', 'knowledgebase', 'folder']),
+      type: z.enum(['table', 'file', 'workflow', 'knowledgebase', 'folder', 'log']),
       id: z.string(),
       title: z.string(),
     })
diff --git a/apps/sim/app/api/copilot/chat/route.ts b/apps/sim/app/api/copilot/chat/route.ts
index 21f83737066..d353e98eacb 100644
--- a/apps/sim/app/api/copilot/chat/route.ts
+++ b/apps/sim/app/api/copilot/chat/route.ts
@@ -1,804 +1,2 @@
-import { db } from '@sim/db'
-import { copilotChats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { and, desc, eq, sql } from 'drizzle-orm'
-import { type NextRequest, NextResponse } from 'next/server'
-import { z } from 'zod'
-import { getSession } from '@/lib/auth'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { getAccessibleCopilotChat, resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
-import { buildCopilotRequestPayload } from '@/lib/copilot/chat-payload'
-import {
-  acquirePendingChatStream,
-  createSSEStream,
-  releasePendingChatStream,
-  requestChatTitle,
-  SSE_RESPONSE_HEADERS,
-} from '@/lib/copilot/chat-streaming'
-import { COPILOT_REQUEST_MODES } from '@/lib/copilot/models'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import { getStreamMeta, readStreamEvents } from '@/lib/copilot/orchestrator/stream/buffer'
-import type { OrchestratorResult } from '@/lib/copilot/orchestrator/types'
-import { resolveActiveResourceContext } from '@/lib/copilot/process-contents'
-import {
-  authenticateCopilotRequestSessionOnly,
-  createBadRequestResponse,
-  createInternalServerErrorResponse,
-  createRequestTracker,
-  createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { generateId } from '@/lib/core/utils/uuid'
-import { captureServerEvent } from '@/lib/posthog/server'
-import {
-  authorizeWorkflowByWorkspacePermission,
-  resolveWorkflowIdForUser,
-} from '@/lib/workflows/utils'
-import {
-  assertActiveWorkspaceAccess,
-  getUserEntityPermissions,
-} from '@/lib/workspaces/permissions/utils'
-
-export const maxDuration = 3600
-
-const logger = createLogger('CopilotChatAPI')
-
-const FileAttachmentSchema = z.object({
-  id: z.string(),
-  key: z.string(),
-  filename: z.string(),
-  media_type: z.string(),
-  size: z.number(),
-})
-
-const ResourceAttachmentSchema = z.object({
-  type: z.enum(['workflow', 'table', 'file', 'knowledgebase']),
-  id: z.string().min(1),
-  title: z.string().optional(),
-  active: z.boolean().optional(),
-})
-
-const ChatMessageSchema = z.object({
-  message: z.string().min(1, 'Message is required'),
-  userMessageId: z.string().optional(),
-  chatId: z.string().optional(),
-  workflowId: z.string().optional(),
-  workspaceId: z.string().optional(),
-  workflowName: z.string().optional(),
-  model: z.string().optional().default('claude-opus-4-6'),
-  mode: z.enum(COPILOT_REQUEST_MODES).optional().default('agent'),
-  prefetch: z.boolean().optional(),
-  createNewChat: z.boolean().optional().default(false),
-  stream: z.boolean().optional().default(true),
-  implicitFeedback: z.string().optional(),
-  fileAttachments: z.array(FileAttachmentSchema).optional(),
-  resourceAttachments: z.array(ResourceAttachmentSchema).optional(),
-  provider: z.string().optional(),
-  contexts: z
-    .array(
-      z.object({
-        kind: z.enum([
-          'past_chat',
-          'workflow',
-          'current_workflow',
-          'blocks',
-          'logs',
-          'workflow_block',
-          'knowledge',
-          'templates',
-          'docs',
-          'table',
-          'file',
-          'folder',
-        ]),
-        label: z.string(),
-        chatId: z.string().optional(),
-        workflowId: z.string().optional(),
-        knowledgeId: z.string().optional(),
-        blockId: z.string().optional(),
-        blockIds: z.array(z.string()).optional(),
-        templateId: z.string().optional(),
-        executionId: z.string().optional(),
-        tableId: z.string().optional(),
-        fileId: z.string().optional(),
-        folderId: z.string().optional(),
-      })
-    )
-    .optional(),
-  commands: z.array(z.string()).optional(),
-  userTimezone: z.string().optional(),
-})
-
-/**
- * POST /api/copilot/chat
- * Send messages to sim agent and handle chat persistence
- */
-export async function POST(req: NextRequest) {
-  const tracker = createRequestTracker()
-  let actualChatId: string | undefined
-  let pendingChatStreamAcquired = false
-  let pendingChatStreamHandedOff = false
-  let pendingChatStreamID: string | undefined
-
-  try {
-    // Get session to access user information including name
-    const session = await getSession()
-
-    if (!session?.user?.id) {
-      return createUnauthorizedResponse()
-    }
-
-    const authenticatedUserId = session.user.id
-
-    const body = await req.json()
-    const {
-      message,
-      userMessageId,
-      chatId,
-      workflowId: providedWorkflowId,
-      workspaceId: requestedWorkspaceId,
-      workflowName,
-      model,
-      mode,
-      prefetch,
-      createNewChat,
-      stream,
-      implicitFeedback,
-      fileAttachments,
-      resourceAttachments,
-      provider,
-      contexts,
-      commands,
-      userTimezone,
-    } = ChatMessageSchema.parse(body)
-
-    const normalizedContexts = Array.isArray(contexts)
-      ? contexts.map((ctx) => {
-          if (ctx.kind !== 'blocks') return ctx
-          if (Array.isArray(ctx.blockIds) && ctx.blockIds.length > 0) return ctx
-          if (ctx.blockId) {
-            return {
-              ...ctx,
-              blockIds: [ctx.blockId],
-            }
-          }
-          return ctx
-        })
-      : contexts
-
-    // Copilot route always requires a workflow scope
-    const resolved = await resolveWorkflowIdForUser(
-      authenticatedUserId,
-      providedWorkflowId,
-      workflowName,
-      requestedWorkspaceId
-    )
-    if (!resolved) {
-      return createBadRequestResponse(
-        'No workflows found. Create a workflow first or provide a valid workflowId.'
-      )
-    }
-    const workflowId = resolved.workflowId
-    const workflowResolvedName = resolved.workflowName
-
-    // Resolve workspace from workflow so it can be sent as implicit context to the copilot.
-    let resolvedWorkspaceId: string | undefined
-    try {
-      const { getWorkflowById } = await import('@/lib/workflows/utils')
-      const wf = await getWorkflowById(workflowId)
-      resolvedWorkspaceId = wf?.workspaceId ?? undefined
-    } catch {
-      logger
-        .withMetadata({ requestId: tracker.requestId, messageId: userMessageId })
-        .warn('Failed to resolve workspaceId from workflow')
-    }
-
-    captureServerEvent(
-      authenticatedUserId,
-      'copilot_chat_sent',
-      {
-        workflow_id: workflowId,
-        workspace_id: resolvedWorkspaceId ?? '',
-        has_file_attachments: Array.isArray(fileAttachments) && fileAttachments.length > 0,
-        has_contexts: Array.isArray(contexts) && contexts.length > 0,
-        mode,
-      },
-      {
-        groups: resolvedWorkspaceId ? { workspace: resolvedWorkspaceId } : undefined,
-        setOnce: { first_copilot_use_at: new Date().toISOString() },
-      }
-    )
-
-    const userMessageIdToUse = userMessageId || generateId()
-    const reqLogger = logger.withMetadata({
-      requestId: tracker.requestId,
-      messageId: userMessageIdToUse,
-    })
-    try {
-      reqLogger.info('Received chat POST', {
-        workflowId,
-        hasContexts: Array.isArray(normalizedContexts),
-        contextsCount: Array.isArray(normalizedContexts) ? normalizedContexts.length : 0,
-        contextsPreview: Array.isArray(normalizedContexts)
-          ? normalizedContexts.map((c: any) => ({
-              kind: c?.kind,
-              chatId: c?.chatId,
-              workflowId: c?.workflowId,
-              executionId: (c as any)?.executionId,
-              label: c?.label,
-            }))
-          : undefined,
-      })
-    } catch {}
-
-    let currentChat: any = null
-    let conversationHistory: any[] = []
-    actualChatId = chatId
-    const selectedModel = model || 'claude-opus-4-6'
-
-    if (chatId || createNewChat) {
-      const chatResult = await resolveOrCreateChat({
-        chatId,
-        userId: authenticatedUserId,
-        workflowId,
-        model: selectedModel,
-      })
-      currentChat = chatResult.chat
-      actualChatId = chatResult.chatId || chatId
-      conversationHistory = Array.isArray(chatResult.conversationHistory)
-        ? chatResult.conversationHistory
-        : []
-
-      if (chatId && !currentChat) {
-        return createBadRequestResponse('Chat not found')
-      }
-    }
-
-    let agentContexts: Array<{ type: string; content: string }> = []
-    if (Array.isArray(normalizedContexts) && normalizedContexts.length > 0) {
-      try {
-        const { processContextsServer } = await import('@/lib/copilot/process-contents')
-        const processed = await processContextsServer(
-          normalizedContexts as any,
-          authenticatedUserId,
-          message,
-          resolvedWorkspaceId,
-          actualChatId
-        )
-        agentContexts = processed
-        reqLogger.info('Contexts processed for request', {
-          processedCount: agentContexts.length,
-          kinds: agentContexts.map((c) => c.type),
-          lengthPreview: agentContexts.map((c) => c.content?.length ?? 0),
-        })
-        if (
-          Array.isArray(normalizedContexts) &&
-          normalizedContexts.length > 0 &&
-          agentContexts.length === 0
-        ) {
-          reqLogger.warn(
-            'Contexts provided but none processed. Check executionId for logs contexts.'
-          )
-        }
-      } catch (e) {
-        reqLogger.error('Failed to process contexts', e)
-      }
-    }
-
-    if (
-      Array.isArray(resourceAttachments) &&
-      resourceAttachments.length > 0 &&
-      resolvedWorkspaceId
-    ) {
-      const results = await Promise.allSettled(
-        resourceAttachments.map(async (r) => {
-          const ctx = await resolveActiveResourceContext(
-            r.type,
-            r.id,
-            resolvedWorkspaceId!,
-            authenticatedUserId,
-            actualChatId
-          )
-          if (!ctx) return null
-          return {
-            ...ctx,
-            tag: r.active ? '@active_tab' : '@open_tab',
-          }
-        })
-      )
-      for (const result of results) {
-        if (result.status === 'fulfilled' && result.value) {
-          agentContexts.push(result.value)
-        } else if (result.status === 'rejected') {
-          reqLogger.error('Failed to resolve resource attachment', result.reason)
-        }
-      }
-    }
-
-    const effectiveMode = mode === 'agent' ? 'build' : mode
-
-    const userPermission = resolvedWorkspaceId
-      ? await getUserEntityPermissions(authenticatedUserId, 'workspace', resolvedWorkspaceId).catch(
-          () => null
-        )
-      : null
-
-    const requestPayload = await buildCopilotRequestPayload(
-      {
-        message,
-        workflowId: workflowId || '',
-        workflowName: workflowResolvedName,
-        workspaceId: resolvedWorkspaceId,
-        userId: authenticatedUserId,
-        userMessageId: userMessageIdToUse,
-        mode,
-        model: selectedModel,
-        provider,
-        contexts: agentContexts,
-        fileAttachments,
-        commands,
-        chatId: actualChatId,
-        prefetch,
-        implicitFeedback,
-        userPermission: userPermission ?? undefined,
-        userTimezone,
-      },
-      {
-        selectedModel,
-      }
-    )
-
-    try {
-      reqLogger.info('About to call Sim Agent', {
-        hasContext: agentContexts.length > 0,
-        contextCount: agentContexts.length,
-        hasFileAttachments: Array.isArray(requestPayload.fileAttachments),
-        messageLength: message.length,
-        mode: effectiveMode,
-        hasTools: Array.isArray(requestPayload.tools),
-        toolCount: Array.isArray(requestPayload.tools) ? requestPayload.tools.length : 0,
-        hasBaseTools: Array.isArray(requestPayload.baseTools),
-        baseToolCount: Array.isArray(requestPayload.baseTools)
-          ? requestPayload.baseTools.length
-          : 0,
-        hasCredentials: !!requestPayload.credentials,
-      })
-    } catch {}
-
-    if (stream && actualChatId) {
-      const acquired = await acquirePendingChatStream(actualChatId, userMessageIdToUse)
-      if (!acquired) {
-        return NextResponse.json(
-          {
-            error:
-              'A response is already in progress for this chat. Wait for it to finish or use Stop.',
-          },
-          { status: 409 }
-        )
-      }
-      pendingChatStreamAcquired = true
-      pendingChatStreamID = userMessageIdToUse
-    }
-
-    if (actualChatId) {
-      const userMsg = {
-        id: userMessageIdToUse,
-        role: 'user' as const,
-        content: message,
-        timestamp: new Date().toISOString(),
-        ...(fileAttachments && fileAttachments.length > 0 && { fileAttachments }),
-        ...(Array.isArray(normalizedContexts) &&
-          normalizedContexts.length > 0 && {
-            contexts: normalizedContexts,
-          }),
-      }
-
-      const [updated] = await db
-        .update(copilotChats)
-        .set({
-          messages: sql`${copilotChats.messages} || ${JSON.stringify([userMsg])}::jsonb`,
-          conversationId: userMessageIdToUse,
-          updatedAt: new Date(),
-        })
-        .where(eq(copilotChats.id, actualChatId))
-        .returning({ messages: copilotChats.messages })
-
-      if (updated) {
-        const freshMessages: any[] = Array.isArray(updated.messages) ? updated.messages : []
-        conversationHistory = freshMessages.filter((m: any) => m.id !== userMessageIdToUse)
-      }
-    }
-
-    if (stream) {
-      const executionId = generateId()
-      const runId = generateId()
-      const sseStream = createSSEStream({
-        requestPayload,
-        userId: authenticatedUserId,
-        streamId: userMessageIdToUse,
-        executionId,
-        runId,
-        chatId: actualChatId,
-        currentChat,
-        isNewChat: conversationHistory.length === 0,
-        message,
-        titleModel: selectedModel,
-        titleProvider: provider,
-        requestId: tracker.requestId,
-        workspaceId: resolvedWorkspaceId,
-        pendingChatStreamAlreadyRegistered: Boolean(actualChatId && stream),
-        orchestrateOptions: {
-          userId: authenticatedUserId,
-          workflowId,
-          chatId: actualChatId,
-          executionId,
-          runId,
-          goRoute: '/api/copilot',
-          autoExecuteTools: true,
-          interactive: true,
-          onComplete: async (result: OrchestratorResult) => {
-            if (!actualChatId) return
-            if (!result.success) return
-
-            const assistantMessage: Record<string, unknown> = {
-              id: generateId(),
-              role: 'assistant' as const,
-              content: result.content,
-              timestamp: new Date().toISOString(),
-              ...(result.requestId ? { requestId: result.requestId } : {}),
-            }
-            if (result.toolCalls.length > 0) {
-              assistantMessage.toolCalls = result.toolCalls
-            }
-            if (result.contentBlocks.length > 0) {
-              assistantMessage.contentBlocks = result.contentBlocks.map((block) => {
-                const stored: Record<string, unknown> = { type: block.type }
-                if (block.content) stored.content = block.content
-                if (block.type === 'tool_call' && block.toolCall) {
-                  const state =
-                    block.toolCall.result?.success !== undefined
-                      ? block.toolCall.result.success
-                        ? 'success'
-                        : 'error'
-                      : block.toolCall.status
-                  const isSubagentTool = !!block.calledBy
-                  const isNonTerminal =
-                    state === 'cancelled' || state === 'pending' || state === 'executing'
-                  stored.toolCall = {
-                    id: block.toolCall.id,
-                    name: block.toolCall.name,
-                    state,
-                    ...(isSubagentTool && isNonTerminal ? {} : { result: block.toolCall.result }),
-                    ...(isSubagentTool && isNonTerminal
-                      ? {}
-                      : block.toolCall.params
-                        ? { params: block.toolCall.params }
-                        : {}),
-                    ...(block.calledBy ? { calledBy: block.calledBy } : {}),
-                  }
-                }
-                return stored
-              })
-            }
-
-            try {
-              const [row] = await db
-                .select({ messages: copilotChats.messages })
-                .from(copilotChats)
-                .where(eq(copilotChats.id, actualChatId))
-                .limit(1)
-
-              const msgs: any[] = Array.isArray(row?.messages) ? row.messages : []
-              const userIdx = msgs.findIndex((m: any) => m.id === userMessageIdToUse)
-              const alreadyHasResponse =
-                userIdx >= 0 &&
-                userIdx + 1 < msgs.length &&
-                (msgs[userIdx + 1] as any)?.role === 'assistant'
-
-              if (!alreadyHasResponse) {
-                await db
-                  .update(copilotChats)
-                  .set({
-                    messages: sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`,
-                    conversationId: sql`CASE WHEN ${copilotChats.conversationId} = ${userMessageIdToUse} THEN NULL ELSE ${copilotChats.conversationId} END`,
-                    updatedAt: new Date(),
-                  })
-                  .where(eq(copilotChats.id, actualChatId))
-              }
-            } catch (error) {
-              reqLogger.error('Failed to persist chat messages', {
-                chatId: actualChatId,
-                error: error instanceof Error ? error.message : 'Unknown error',
-              })
-            }
-          },
-        },
-      })
-      pendingChatStreamHandedOff = true
-
-      return new Response(sseStream, { headers: SSE_RESPONSE_HEADERS })
-    }
-
-    const nsExecutionId = generateId()
-    const nsRunId = generateId()
-
-    if (actualChatId) {
-      await createRunSegment({
-        id: nsRunId,
-        executionId: nsExecutionId,
-        chatId: actualChatId,
-        userId: authenticatedUserId,
-        workflowId,
-        streamId: userMessageIdToUse,
-      }).catch(() => {})
-    }
-
-    const nonStreamingResult = await orchestrateCopilotStream(requestPayload, {
-      userId: authenticatedUserId,
-      workflowId,
-      chatId: actualChatId,
-      executionId: nsExecutionId,
-      runId: nsRunId,
-      goRoute: '/api/copilot',
-      autoExecuteTools: true,
-      interactive: true,
-    })
-
-    const responseData = {
-      content: nonStreamingResult.content,
-      toolCalls: nonStreamingResult.toolCalls,
-      model: selectedModel,
-      provider: typeof requestPayload?.provider === 'string' ? requestPayload.provider : undefined,
-    }
-
-    reqLogger.info('Non-streaming response from orchestrator', {
-      hasContent: !!responseData.content,
-      contentLength: responseData.content?.length || 0,
-      model: responseData.model,
-      provider: responseData.provider,
-      toolCallsCount: responseData.toolCalls?.length || 0,
-    })
-
-    // Save messages if we have a chat
-    if (currentChat && responseData.content) {
-      const userMessage = {
-        id: userMessageIdToUse, // Consistent ID used for request and persistence
-        role: 'user',
-        content: message,
-        timestamp: new Date().toISOString(),
-        ...(fileAttachments && fileAttachments.length > 0 && { fileAttachments }),
-        ...(Array.isArray(normalizedContexts) &&
-          normalizedContexts.length > 0 && {
-            contexts: normalizedContexts,
-          }),
-        ...(Array.isArray(normalizedContexts) &&
-          normalizedContexts.length > 0 && {
-            contentBlocks: [
-              { type: 'contexts', contexts: normalizedContexts as any, timestamp: Date.now() },
-            ],
-          }),
-      }
-
-      const assistantMessage = {
-        id: generateId(),
-        role: 'assistant',
-        content: responseData.content,
-        timestamp: new Date().toISOString(),
-      }
-
-      const updatedMessages = [...conversationHistory, userMessage, assistantMessage]
-
-      // Start title generation in parallel if this is first message (non-streaming)
-      if (actualChatId && !currentChat.title && conversationHistory.length === 0) {
-        reqLogger.info('Starting title generation for non-streaming response')
-        requestChatTitle({ message, model: selectedModel, provider, messageId: userMessageIdToUse })
-          .then(async (title) => {
-            if (title) {
-              await db
-                .update(copilotChats)
-                .set({
-                  title,
-                  updatedAt: new Date(),
-                })
-                .where(eq(copilotChats.id, actualChatId!))
-              reqLogger.info(`Generated and saved title: ${title}`)
-            }
-          })
-          .catch((error) => {
-            reqLogger.error('Title generation failed', error)
-          })
-      }
-
-      // Update chat in database immediately (without blocking for title)
-      await db
-        .update(copilotChats)
-        .set({
-          messages: updatedMessages,
-          updatedAt: new Date(),
-        })
-        .where(eq(copilotChats.id, actualChatId!))
-    }
-
-    reqLogger.info('Returning non-streaming response', {
-      duration: tracker.getDuration(),
-      chatId: actualChatId,
-      responseLength: responseData.content?.length || 0,
-    })
-
-    return NextResponse.json({
-      success: true,
-      response: responseData,
-      chatId: actualChatId,
-      metadata: {
-        requestId: tracker.requestId,
-        message,
-        duration: tracker.getDuration(),
-      },
-    })
-  } catch (error) {
-    if (
-      actualChatId &&
-      pendingChatStreamAcquired &&
-      !pendingChatStreamHandedOff &&
-      pendingChatStreamID
-    ) {
-      await releasePendingChatStream(actualChatId, pendingChatStreamID).catch(() => {})
-    }
-    const duration = tracker.getDuration()
-
-    if (error instanceof z.ZodError) {
-      logger
-        .withMetadata({ requestId: tracker.requestId, messageId: pendingChatStreamID ?? undefined })
-        .error('Validation error', {
-          duration,
-          errors: error.errors,
-        })
-      return NextResponse.json(
-        { error: 'Invalid request data', details: error.errors },
-        { status: 400 }
-      )
-    }
-
-    logger
-      .withMetadata({ requestId: tracker.requestId, messageId: pendingChatStreamID ?? undefined })
-      .error('Error handling copilot chat', {
-        duration,
-        error: error instanceof Error ? error.message : 'Unknown error',
-        stack: error instanceof Error ? error.stack : undefined,
-      })
-
-    return NextResponse.json(
-      { error: error instanceof Error ? error.message : 'Internal server error' },
-      { status: 500 }
-    )
-  }
-}
-
-export async function GET(req: NextRequest) {
-  try {
-    const { searchParams } = new URL(req.url)
-    const workflowId = searchParams.get('workflowId')
-    const workspaceId = searchParams.get('workspaceId')
-    const chatId = searchParams.get('chatId')
-
-    const { userId: authenticatedUserId, isAuthenticated } =
-      await authenticateCopilotRequestSessionOnly()
-    if (!isAuthenticated || !authenticatedUserId) {
-      return createUnauthorizedResponse()
-    }
-
-    if (chatId) {
-      const chat = await getAccessibleCopilotChat(chatId, authenticatedUserId)
-
-      if (!chat) {
-        return NextResponse.json({ success: false, error: 'Chat not found' }, { status: 404 })
-      }
-
-      let streamSnapshot: {
-        events: Array<{ eventId: number; streamId: string; event: Record<string, unknown> }>
-        status: string
-      } | null = null
-
-      if (chat.conversationId) {
-        try {
-          const [meta, events] = await Promise.all([
-            getStreamMeta(chat.conversationId),
-            readStreamEvents(chat.conversationId, 0),
-          ])
-          streamSnapshot = {
-            events: events || [],
-            status: meta?.status || 'unknown',
-          }
-        } catch (err) {
-          logger
-            .withMetadata({ messageId: chat.conversationId || undefined })
-            .warn('Failed to read stream snapshot for chat', {
-              chatId,
-              conversationId: chat.conversationId,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        }
-      }
-
-      const transformedChat = {
-        id: chat.id,
-        title: chat.title,
-        model: chat.model,
-        messages: Array.isArray(chat.messages) ? chat.messages : [],
-        messageCount: Array.isArray(chat.messages) ? chat.messages.length : 0,
-        planArtifact: chat.planArtifact || null,
-        config: chat.config || null,
-        conversationId: chat.conversationId || null,
-        resources: Array.isArray(chat.resources) ? chat.resources : [],
-        createdAt: chat.createdAt,
-        updatedAt: chat.updatedAt,
-        ...(streamSnapshot ? { streamSnapshot } : {}),
-      }
-
-      logger
-        .withMetadata({ messageId: chat.conversationId || undefined })
-        .info(`Retrieved chat ${chatId}`)
-      return NextResponse.json({ success: true, chat: transformedChat })
-    }
-
-    if (!workflowId && !workspaceId) {
-      return createBadRequestResponse('workflowId, workspaceId, or chatId is required')
-    }
-
-    if (workspaceId) {
-      await assertActiveWorkspaceAccess(workspaceId, authenticatedUserId)
-    }
-
-    if (workflowId) {
-      const authorization = await authorizeWorkflowByWorkspacePermission({
-        workflowId,
-        userId: authenticatedUserId,
-        action: 'read',
-      })
-      if (!authorization.allowed) {
-        return createUnauthorizedResponse()
-      }
-    }
-
-    const scopeFilter = workflowId
-      ? eq(copilotChats.workflowId, workflowId)
-      : eq(copilotChats.workspaceId, workspaceId!)
-
-    const chats = await db
-      .select({
-        id: copilotChats.id,
-        title: copilotChats.title,
-        model: copilotChats.model,
-        messages: copilotChats.messages,
-        planArtifact: copilotChats.planArtifact,
-        config: copilotChats.config,
-        createdAt: copilotChats.createdAt,
-        updatedAt: copilotChats.updatedAt,
-      })
-      .from(copilotChats)
-      .where(and(eq(copilotChats.userId, authenticatedUserId), scopeFilter))
-      .orderBy(desc(copilotChats.updatedAt))
-
-    const transformedChats = chats.map((chat) => ({
-      id: chat.id,
-      title: chat.title,
-      model: chat.model,
-      messages: Array.isArray(chat.messages) ? chat.messages : [],
-      messageCount: Array.isArray(chat.messages) ? chat.messages.length : 0,
-      planArtifact: chat.planArtifact || null,
-      config: chat.config || null,
-      createdAt: chat.createdAt,
-      updatedAt: chat.updatedAt,
-    }))
-
-    const scope = workflowId ? `workflow ${workflowId}` : `workspace ${workspaceId}`
-    logger.info(`Retrieved ${transformedChats.length} chats for ${scope}`)
-
-    return NextResponse.json({
-      success: true,
-      chats: transformedChats,
-    })
-  } catch (error) {
-    logger.error('Error fetching copilot chats', error)
-    return createInternalServerErrorResponse('Failed to fetch chats')
-  }
-}
+export { handleUnifiedChatPost as POST, maxDuration } from '@/lib/copilot/chat/post'
+export { GET } from './queries'
diff --git a/apps/sim/app/api/copilot/chat/stop/route.ts b/apps/sim/app/api/copilot/chat/stop/route.ts
new file mode 100644
index 00000000000..8a742d7080e
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/stop/route.ts
@@ -0,0 +1,144 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { getSession } from '@/lib/auth'
+import { normalizeMessage, type PersistedMessage } from '@/lib/copilot/chat/persisted-message'
+import { taskPubSub } from '@/lib/copilot/tasks'
+
+const logger = createLogger('CopilotChatStopAPI')
+
+const StoredToolCallSchema = z
+  .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    state: z.string().optional(),
+    params: z.record(z.unknown()).optional(),
+    result: z
+      .object({
+        success: z.boolean(),
+        output: z.unknown().optional(),
+        error: z.string().optional(),
+      })
+      .optional(),
+    display: z
+      .object({
+        text: z.string().optional(),
+        title: z.string().optional(),
+        phaseLabel: z.string().optional(),
+      })
+      .optional(),
+    calledBy: z.string().optional(),
+    durationMs: z.number().optional(),
+    error: z.string().optional(),
+  })
+  .nullable()
+
+const ContentBlockSchema = z.object({
+  type: z.string(),
+  lane: z.enum(['main', 'subagent']).optional(),
+  content: z.string().optional(),
+  channel: z.enum(['assistant', 'thinking']).optional(),
+  phase: z.enum(['call', 'args_delta', 'result']).optional(),
+  kind: z.enum(['subagent', 'structured_result', 'subagent_result']).optional(),
+  lifecycle: z.enum(['start', 'end']).optional(),
+  status: z.enum(['complete', 'error', 'cancelled']).optional(),
+  toolCall: StoredToolCallSchema.optional(),
+})
+
+const StopSchema = z.object({
+  chatId: z.string(),
+  streamId: z.string(),
+  content: z.string(),
+  contentBlocks: z.array(ContentBlockSchema).optional(),
+})
+
+/**
+ * POST /api/copilot/chat/stop
+ * Persists partial assistant content when the user stops a stream mid-response.
+ * Clears conversationId so the server-side onComplete won't duplicate the message.
+ * The chat stream lock is intentionally left alone here; it is released only once
+ * the aborted server stream actually unwinds.
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { chatId, streamId, content, contentBlocks } = StopSchema.parse(await req.json())
+
+    const [row] = await db
+      .select({
+        workspaceId: copilotChats.workspaceId,
+        messages: copilotChats.messages,
+      })
+      .from(copilotChats)
+      .where(and(eq(copilotChats.id, chatId), eq(copilotChats.userId, session.user.id)))
+      .limit(1)
+
+    if (!row) {
+      return NextResponse.json({ success: true })
+    }
+
+    const messages: Record<string, unknown>[] = Array.isArray(row.messages) ? row.messages : []
+    const userIdx = messages.findIndex((message) => message.id === streamId)
+    const alreadyHasResponse =
+      userIdx >= 0 &&
+      userIdx + 1 < messages.length &&
+      (messages[userIdx + 1] as Record<string, unknown>)?.role === 'assistant'
+    const canAppendAssistant =
+      userIdx >= 0 && userIdx === messages.length - 1 && !alreadyHasResponse
+
+    const updateWhere = and(
+      eq(copilotChats.id, chatId),
+      eq(copilotChats.userId, session.user.id),
+      eq(copilotChats.conversationId, streamId)
+    )
+
+    const setClause: Record<string, unknown> = {
+      conversationId: null,
+      updatedAt: new Date(),
+    }
+
+    const hasContent = content.trim().length > 0
+    const hasBlocks = Array.isArray(contentBlocks) && contentBlocks.length > 0
+
+    if ((hasContent || hasBlocks) && canAppendAssistant) {
+      const normalized = normalizeMessage({
+        id: crypto.randomUUID(),
+        role: 'assistant',
+        content,
+        timestamp: new Date().toISOString(),
+        ...(hasBlocks ? { contentBlocks } : {}),
+      })
+      const assistantMessage: PersistedMessage = normalized
+      setClause.messages = sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`
+    }
+
+    const [updated] = await db
+      .update(copilotChats)
+      .set(setClause)
+      .where(updateWhere)
+      .returning({ workspaceId: copilotChats.workspaceId })
+
+    if (updated?.workspaceId) {
+      taskPubSub?.publishStatusChanged({
+        workspaceId: updated.workspaceId,
+        chatId,
+        type: 'completed',
+      })
+    }
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Invalid request' }, { status: 400 })
+    }
+    logger.error('Error stopping chat stream:', error)
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/copilot/chat/stream/route.test.ts b/apps/sim/app/api/copilot/chat/stream/route.test.ts
index 993f10501a8..3105f9216ce 100644
--- a/apps/sim/app/api/copilot/chat/stream/route.test.ts
+++ b/apps/sim/app/api/copilot/chat/stream/route.test.ts
@@ -4,25 +4,70 @@
 
 import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
 
-const { getStreamMeta, readStreamEvents, authenticateCopilotRequestSessionOnly } = vi.hoisted(
-  () => ({
-    getStreamMeta: vi.fn(),
-    readStreamEvents: vi.fn(),
-    authenticateCopilotRequestSessionOnly: vi.fn(),
-  })
-)
+const {
+  getLatestRunForStream,
+  readEvents,
+  readFilePreviewSessions,
+  checkForReplayGap,
+  authenticateCopilotRequestSessionOnly,
+} = vi.hoisted(() => ({
+  getLatestRunForStream: vi.fn(),
+  readEvents: vi.fn(),
+  readFilePreviewSessions: vi.fn(),
+  checkForReplayGap: vi.fn(),
+  authenticateCopilotRequestSessionOnly: vi.fn(),
+}))
 
-vi.mock('@/lib/copilot/orchestrator/stream/buffer', () => ({
-  getStreamMeta,
-  readStreamEvents,
+vi.mock('@/lib/copilot/async-runs/repository', () => ({
+  getLatestRunForStream,
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/session', () => ({
+  readEvents,
+  readFilePreviewSessions,
+  checkForReplayGap,
+  createEvent: (event: Record<string, unknown>) => ({
+    stream: {
+      streamId: event.streamId,
+      cursor: event.cursor,
+    },
+    seq: event.seq,
+    trace: { requestId: event.requestId ?? '' },
+    type: event.type,
+    payload: event.payload,
+  }),
+  encodeSSEEnvelope: (event: Record<string, unknown>) =>
+    new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`),
+  SSE_RESPONSE_HEADERS: {
+    'Content-Type': 'text/event-stream',
+  },
+}))
+
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly,
 }))
 
-import { GET } from '@/app/api/copilot/chat/stream/route'
+import { GET } from './route'
+
+async function readAllChunks(response: Response): Promise<string[]> {
+  const reader = response.body?.getReader()
+  expect(reader).toBeTruthy()
+
+  const chunks: string[] = []
+  while (true) {
+    const { done, value } = await reader!.read()
+    if (done) {
+      break
+    }
+    chunks.push(new TextDecoder().decode(value))
+  }
+  return chunks
+}
 
 describe('copilot chat stream replay route', () => {
   beforeEach(() => {
@@ -31,29 +76,95 @@ describe('copilot chat stream replay route', () => {
       userId: 'user-1',
       isAuthenticated: true,
     })
-    readStreamEvents.mockResolvedValue([])
+    readEvents.mockResolvedValue([])
+    readFilePreviewSessions.mockResolvedValue([])
+    checkForReplayGap.mockResolvedValue(null)
   })
 
-  it('stops replay polling when stream meta becomes cancelled', async () => {
-    getStreamMeta
+  it('returns preview sessions in batch mode', async () => {
+    getLatestRunForStream.mockResolvedValue({
+      status: 'active',
+      executionId: 'exec-1',
+      id: 'run-1',
+    })
+    readFilePreviewSessions.mockResolvedValue([
+      {
+        schemaVersion: 1,
+        id: 'preview-1',
+        streamId: 'stream-1',
+        toolCallId: 'preview-1',
+        status: 'streaming',
+        fileName: 'draft.md',
+        previewText: 'hello',
+        previewVersion: 2,
+        updatedAt: '2026-04-10T00:00:00.000Z',
+      },
+    ])
+
+    const response = await GET(
+      new NextRequest(
+        'http://localhost:3000/api/copilot/chat/stream?streamId=stream-1&after=0&batch=true'
+      )
+    )
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toMatchObject({
+      success: true,
+      previewSessions: [
+        expect.objectContaining({
+          id: 'preview-1',
+          previewText: 'hello',
+          previewVersion: 2,
+        }),
+      ],
+      status: 'active',
+    })
+  })
+
+  it('stops replay polling when run becomes cancelled', async () => {
+    getLatestRunForStream
       .mockResolvedValueOnce({
         status: 'active',
-        userId: 'user-1',
+        executionId: 'exec-1',
+        id: 'run-1',
       })
       .mockResolvedValueOnce({
         status: 'cancelled',
-        userId: 'user-1',
+        executionId: 'exec-1',
+        id: 'run-1',
       })
 
     const response = await GET(
-      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1')
+      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1&after=0')
+    )
+
+    const chunks = await readAllChunks(response)
+    expect(chunks.join('')).toContain(
+      JSON.stringify({
+        status: MothershipStreamV1CompletionStatus.cancelled,
+        reason: 'terminal_status',
+      })
     )
+    expect(getLatestRunForStream).toHaveBeenCalledTimes(2)
+  })
 
-    const reader = response.body?.getReader()
-    expect(reader).toBeTruthy()
+  it('emits structured terminal replay error when run metadata disappears', async () => {
+    getLatestRunForStream
+      .mockResolvedValueOnce({
+        status: 'active',
+        executionId: 'exec-1',
+        id: 'run-1',
+      })
+      .mockResolvedValueOnce(null)
+
+    const response = await GET(
+      new NextRequest('http://localhost:3000/api/copilot/chat/stream?streamId=stream-1&after=0')
+    )
 
-    const first = await reader!.read()
-    expect(first.done).toBe(true)
-    expect(getStreamMeta).toHaveBeenCalledTimes(2)
+    const chunks = await readAllChunks(response)
+    const body = chunks.join('')
+    expect(body).toContain(`"type":"${MothershipStreamV1EventType.error}"`)
+    expect(body).toContain('"code":"resume_run_unavailable"')
+    expect(body).toContain(`"type":"${MothershipStreamV1EventType.complete}"`)
   })
 })
diff --git a/apps/sim/app/api/copilot/chat/stream/route.ts b/apps/sim/app/api/copilot/chat/stream/route.ts
index b56d9471817..5028ecf7e5e 100644
--- a/apps/sim/app/api/copilot/chat/stream/route.ts
+++ b/apps/sim/app/api/copilot/chat/stream/route.ts
@@ -1,12 +1,20 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
+import { getLatestRunForStream } from '@/lib/copilot/async-runs/repository'
 import {
-  getStreamMeta,
-  readStreamEvents,
-  type StreamMeta,
-} from '@/lib/copilot/orchestrator/stream/buffer'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
-import { SSE_HEADERS } from '@/lib/core/utils/sse'
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
+import {
+  checkForReplayGap,
+  createEvent,
+  encodeSSEEnvelope,
+  readEvents,
+  readFilePreviewSessions,
+  SSE_RESPONSE_HEADERS,
+} from '@/lib/copilot/request/session'
+import { toStreamBatchEvent } from '@/lib/copilot/request/session/types'
 
 export const maxDuration = 3600
 
@@ -14,8 +22,59 @@ const logger = createLogger('CopilotChatStreamAPI')
 const POLL_INTERVAL_MS = 250
 const MAX_STREAM_MS = 60 * 60 * 1000
 
-function encodeEvent(event: Record<string, any>): Uint8Array {
-  return new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`)
+function isTerminalStatus(
+  status: string | null | undefined
+): status is MothershipStreamV1CompletionStatus {
+  return (
+    status === MothershipStreamV1CompletionStatus.complete ||
+    status === MothershipStreamV1CompletionStatus.error ||
+    status === MothershipStreamV1CompletionStatus.cancelled
+  )
+}
+
+function buildResumeTerminalEnvelopes(options: {
+  streamId: string
+  afterCursor: string
+  status: MothershipStreamV1CompletionStatus
+  message?: string
+  code: string
+  reason?: string
+}) {
+  const baseSeq = Number(options.afterCursor || '0')
+  const seq = Number.isFinite(baseSeq) ? baseSeq : 0
+  const envelopes: ReturnType<typeof createEvent>[] = []
+
+  if (options.status === MothershipStreamV1CompletionStatus.error) {
+    envelopes.push(
+      createEvent({
+        streamId: options.streamId,
+        cursor: String(seq + 1),
+        seq: seq + 1,
+        requestId: '',
+        type: MothershipStreamV1EventType.error,
+        payload: {
+          message: options.message || 'Stream recovery failed before completion.',
+          code: options.code,
+        },
+      })
+    )
+  }
+
+  envelopes.push(
+    createEvent({
+      streamId: options.streamId,
+      cursor: String(seq + envelopes.length + 1),
+      seq: seq + envelopes.length + 1,
+      requestId: '',
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: options.status,
+        ...(options.reason ? { reason: options.reason } : {}),
+      },
+    })
+  )
+
+  return envelopes
 }
 
 export async function GET(request: NextRequest) {
@@ -28,58 +87,56 @@ export async function GET(request: NextRequest) {
 
   const url = new URL(request.url)
   const streamId = url.searchParams.get('streamId') || ''
-  const fromParam = url.searchParams.get('from') || '0'
-  const fromEventId = Number(fromParam || 0)
-  // If batch=true, return buffered events as JSON instead of SSE
+  const afterCursor = url.searchParams.get('after') || ''
   const batchMode = url.searchParams.get('batch') === 'true'
-  const toParam = url.searchParams.get('to')
-  const toEventId = toParam ? Number(toParam) : undefined
-
-  const reqLogger = logger.withMetadata({ messageId: streamId || undefined })
-
-  reqLogger.info('[Resume] Received resume request', {
-    streamId: streamId || undefined,
-    fromEventId,
-    toEventId,
-    batchMode,
-  })
 
   if (!streamId) {
     return NextResponse.json({ error: 'streamId is required' }, { status: 400 })
   }
 
-  const meta = (await getStreamMeta(streamId)) as StreamMeta | null
-  reqLogger.info('[Resume] Stream lookup', {
+  const run = await getLatestRunForStream(streamId, authenticatedUserId).catch((err) => {
+    logger.warn('Failed to fetch latest run for stream', {
+      streamId,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return null
+  })
+  logger.info('[Resume] Stream lookup', {
     streamId,
-    fromEventId,
-    toEventId,
+    afterCursor,
     batchMode,
-    hasMeta: !!meta,
-    metaStatus: meta?.status,
+    hasRun: !!run,
+    runStatus: run?.status,
   })
-  if (!meta) {
+  if (!run) {
     return NextResponse.json({ error: 'Stream not found' }, { status: 404 })
   }
-  if (meta.userId && meta.userId !== authenticatedUserId) {
-    return NextResponse.json({ error: 'Unauthorized' }, { status: 403 })
-  }
 
-  // Batch mode: return all buffered events as JSON
   if (batchMode) {
-    const events = await readStreamEvents(streamId, fromEventId)
-    const filteredEvents = toEventId ? events.filter((e) => e.eventId <= toEventId) : events
-    reqLogger.info('[Resume] Batch response', {
+    const afterSeq = afterCursor || '0'
+    const [events, previewSessions] = await Promise.all([
+      readEvents(streamId, afterSeq),
+      readFilePreviewSessions(streamId).catch((error) => {
+        logger.warn('Failed to read preview sessions for stream batch', {
+          streamId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+        return []
+      }),
+    ])
+    const batchEvents = events.map(toStreamBatchEvent)
+    logger.info('[Resume] Batch response', {
       streamId,
-      fromEventId,
-      toEventId,
-      eventCount: filteredEvents.length,
+      afterCursor: afterSeq,
+      eventCount: batchEvents.length,
+      previewSessionCount: previewSessions.length,
+      runStatus: run.status,
     })
     return NextResponse.json({
       success: true,
-      events: filteredEvents,
-      status: meta.status,
-      executionId: meta.executionId,
-      runId: meta.runId,
+      events: batchEvents,
+      previewSessions,
+      status: run.status,
     })
   }
 
@@ -87,9 +144,9 @@ export async function GET(request: NextRequest) {
 
   const stream = new ReadableStream({
     async start(controller) {
-      let lastEventId = Number.isFinite(fromEventId) ? fromEventId : 0
-      let latestMeta = meta
+      let cursor = afterCursor || '0'
       let controllerClosed = false
+      let sawTerminalEvent = false
 
       const closeController = () => {
         if (controllerClosed) return
@@ -97,14 +154,14 @@ export async function GET(request: NextRequest) {
         try {
           controller.close()
         } catch {
-          // Controller already closed by runtime/client - treat as normal.
+          // Controller already closed by runtime/client
         }
       }
 
-      const enqueueEvent = (payload: Record<string, any>) => {
+      const enqueueEvent = (payload: unknown) => {
         if (controllerClosed) return false
         try {
-          controller.enqueue(encodeEvent(payload))
+          controller.enqueue(encodeSSEEnvelope(payload))
           return true
         } catch {
           controllerClosed = true
@@ -118,47 +175,96 @@ export async function GET(request: NextRequest) {
       request.signal.addEventListener('abort', abortListener, { once: true })
 
       const flushEvents = async () => {
-        const events = await readStreamEvents(streamId, lastEventId)
+        const events = await readEvents(streamId, cursor)
         if (events.length > 0) {
-          reqLogger.info('[Resume] Flushing events', {
+          logger.info('[Resume] Flushing events', {
             streamId,
-            fromEventId: lastEventId,
+            afterCursor: cursor,
             eventCount: events.length,
           })
         }
-        for (const entry of events) {
-          lastEventId = entry.eventId
-          const payload = {
-            ...entry.event,
-            eventId: entry.eventId,
-            streamId: entry.streamId,
-            executionId: latestMeta?.executionId,
-            runId: latestMeta?.runId,
+        for (const envelope of events) {
+          cursor = envelope.stream.cursor ?? String(envelope.seq)
+          if (envelope.type === MothershipStreamV1EventType.complete) {
+            sawTerminalEvent = true
           }
-          if (!enqueueEvent(payload)) {
+          if (!enqueueEvent(envelope)) {
+            break
+          }
+        }
+      }
+
+      const emitTerminalIfMissing = (
+        status: MothershipStreamV1CompletionStatus,
+        options?: { message?: string; code: string; reason?: string }
+      ) => {
+        if (controllerClosed || sawTerminalEvent) {
+          return
+        }
+        for (const envelope of buildResumeTerminalEnvelopes({
+          streamId,
+          afterCursor: cursor,
+          status,
+          message: options?.message,
+          code: options?.code ?? 'resume_terminal',
+          reason: options?.reason,
+        })) {
+          cursor = envelope.stream.cursor ?? String(envelope.seq)
+          if (envelope.type === MothershipStreamV1EventType.complete) {
+            sawTerminalEvent = true
+          }
+          if (!enqueueEvent(envelope)) {
             break
           }
         }
       }
 
       try {
+        const gap = await checkForReplayGap(streamId, afterCursor)
+        if (gap) {
+          for (const envelope of gap.envelopes) {
+            enqueueEvent(envelope)
+          }
+          return
+        }
+
         await flushEvents()
 
         while (!controllerClosed && Date.now() - startTime < MAX_STREAM_MS) {
-          const currentMeta = await getStreamMeta(streamId)
-          if (!currentMeta) break
-          latestMeta = currentMeta
+          const currentRun = await getLatestRunForStream(streamId, authenticatedUserId).catch(
+            (err) => {
+              logger.warn('Failed to poll latest run for stream', {
+                streamId,
+                error: err instanceof Error ? err.message : String(err),
+              })
+              return null
+            }
+          )
+          if (!currentRun) {
+            emitTerminalIfMissing(MothershipStreamV1CompletionStatus.error, {
+              message: 'The stream could not be recovered because its run metadata is unavailable.',
+              code: 'resume_run_unavailable',
+              reason: 'run_unavailable',
+            })
+            break
+          }
 
           await flushEvents()
 
           if (controllerClosed) {
             break
           }
-          if (
-            currentMeta.status === 'complete' ||
-            currentMeta.status === 'error' ||
-            currentMeta.status === 'cancelled'
-          ) {
+          if (isTerminalStatus(currentRun.status)) {
+            emitTerminalIfMissing(currentRun.status, {
+              message:
+                currentRun.status === MothershipStreamV1CompletionStatus.error
+                  ? typeof currentRun.error === 'string'
+                    ? currentRun.error
+                    : 'The recovered stream ended with an error.'
+                  : undefined,
+              code: 'resume_terminal_status',
+              reason: 'terminal_status',
+            })
             break
           }
 
@@ -169,12 +275,24 @@ export async function GET(request: NextRequest) {
 
           await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
         }
+        if (!controllerClosed && Date.now() - startTime >= MAX_STREAM_MS) {
+          emitTerminalIfMissing(MothershipStreamV1CompletionStatus.error, {
+            message: 'The stream recovery timed out before completion.',
+            code: 'resume_timeout',
+            reason: 'timeout',
+          })
+        }
       } catch (error) {
         if (!controllerClosed && !request.signal.aborted) {
-          reqLogger.warn('Stream replay failed', {
+          logger.warn('Stream replay failed', {
             streamId,
             error: error instanceof Error ? error.message : String(error),
           })
+          emitTerminalIfMissing(MothershipStreamV1CompletionStatus.error, {
+            message: 'The stream replay failed before completion.',
+            code: 'resume_internal',
+            reason: 'stream_replay_failed',
+          })
         }
       } finally {
         request.signal.removeEventListener('abort', abortListener)
@@ -183,5 +301,5 @@ export async function GET(request: NextRequest) {
     },
   })
 
-  return new Response(stream, { headers: SSE_HEADERS })
+  return new Response(stream, { headers: SSE_RESPONSE_HEADERS })
 }
diff --git a/apps/sim/app/api/copilot/chat/update-messages/route.test.ts b/apps/sim/app/api/copilot/chat/update-messages/route.test.ts
index 0376005c283..512a05cfd84 100644
--- a/apps/sim/app/api/copilot/chat/update-messages/route.test.ts
+++ b/apps/sim/app/api/copilot/chat/update-messages/route.test.ts
@@ -327,7 +327,35 @@ describe('Copilot Chat Update Messages API Route', () => {
       })
 
       expect(mockSet).toHaveBeenCalledWith({
-        messages,
+        messages: [
+          {
+            id: 'msg-1',
+            role: 'user',
+            content: 'Hello',
+            timestamp: '2024-01-01T10:00:00.000Z',
+          },
+          {
+            id: 'msg-2',
+            role: 'assistant',
+            content: 'Hi there!',
+            timestamp: '2024-01-01T10:01:00.000Z',
+            contentBlocks: [
+              {
+                type: 'text',
+                content: 'Here is the weather information',
+              },
+              {
+                type: 'tool',
+                phase: 'call',
+                toolCall: {
+                  id: 'tool-1',
+                  name: 'get_weather',
+                  state: 'pending',
+                },
+              },
+            ],
+          },
+        ],
         updatedAt: expect.any(Date),
       })
     })
diff --git a/apps/sim/app/api/copilot/chat/update-messages/route.ts b/apps/sim/app/api/copilot/chat/update-messages/route.ts
index 574c2241ede..ee2dfee0bb7 100644
--- a/apps/sim/app/api/copilot/chat/update-messages/route.ts
+++ b/apps/sim/app/api/copilot/chat/update-messages/route.ts
@@ -4,15 +4,16 @@ import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
-import { COPILOT_MODES } from '@/lib/copilot/models'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
+import { normalizeMessage, type PersistedMessage } from '@/lib/copilot/chat/persisted-message'
+import { COPILOT_MODES } from '@/lib/copilot/constants'
 import {
   authenticateCopilotRequestSessionOnly,
   createInternalServerErrorResponse,
   createNotFoundResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 
 const logger = createLogger('CopilotChatUpdateAPI')
 
@@ -78,12 +79,15 @@ export async function POST(req: NextRequest) {
     }
 
     const { chatId, messages, planArtifact, config } = UpdateMessagesSchema.parse(body)
+    const normalizedMessages: PersistedMessage[] = messages.map((message) =>
+      normalizeMessage(message as Record<string, unknown>)
+    )
 
     // Debug: Log what we're about to save
-    const lastMsgParsed = messages[messages.length - 1]
+    const lastMsgParsed = normalizedMessages[normalizedMessages.length - 1]
     if (lastMsgParsed?.role === 'assistant') {
       logger.info(`[${tracker.requestId}] Parsed messages to save`, {
-        messageCount: messages.length,
+        messageCount: normalizedMessages.length,
         lastMsgId: lastMsgParsed.id,
         lastMsgContentLength: lastMsgParsed.content?.length || 0,
         lastMsgContentBlockCount: lastMsgParsed.contentBlocks?.length || 0,
@@ -99,8 +103,8 @@ export async function POST(req: NextRequest) {
     }
 
     // Update chat with new messages, plan artifact, and config
-    const updateData: Record<string, any> = {
-      messages: messages,
+    const updateData: Record<string, unknown> = {
+      messages: normalizedMessages,
       updatedAt: new Date(),
     }
 
@@ -116,14 +120,14 @@ export async function POST(req: NextRequest) {
 
     logger.info(`[${tracker.requestId}] Successfully updated chat`, {
       chatId,
-      newMessageCount: messages.length,
+      newMessageCount: normalizedMessages.length,
       hasPlanArtifact: !!planArtifact,
       hasConfig: !!config,
     })
 
     return NextResponse.json({
       success: true,
-      messageCount: messages.length,
+      messageCount: normalizedMessages.length,
     })
   } catch (error) {
     logger.error(`[${tracker.requestId}] Error updating chat messages:`, error)
diff --git a/apps/sim/app/api/copilot/chats/route.test.ts b/apps/sim/app/api/copilot/chats/route.test.ts
index 32088fe093a..3dbbf2791f8 100644
--- a/apps/sim/app/api/copilot/chats/route.test.ts
+++ b/apps/sim/app/api/copilot/chats/route.test.ts
@@ -66,7 +66,7 @@ vi.mock('drizzle-orm', () => ({
   sql: vi.fn(),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly: mockAuthenticate,
   createUnauthorizedResponse: mockCreateUnauthorizedResponse,
   createInternalServerErrorResponse: mockCreateInternalServerErrorResponse,
diff --git a/apps/sim/app/api/copilot/chats/route.ts b/apps/sim/app/api/copilot/chats/route.ts
index 7010d84e92b..b0142c27f7b 100644
--- a/apps/sim/app/api/copilot/chats/route.ts
+++ b/apps/sim/app/api/copilot/chats/route.ts
@@ -4,14 +4,14 @@ import { createLogger } from '@sim/logger'
 import { and, desc, eq, isNull, or, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
+import { resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
+} from '@/lib/copilot/request/http'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -37,7 +37,7 @@ export async function GET(_request: NextRequest) {
         title: copilotChats.title,
         workflowId: copilotChats.workflowId,
         workspaceId: copilotChats.workspaceId,
-        conversationId: copilotChats.conversationId,
+        activeStreamId: copilotChats.conversationId,
         updatedAt: copilotChats.updatedAt,
       })
       .from(copilotChats)
diff --git a/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts b/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts
index 7fd68b4925e..fe4fb76f4d1 100644
--- a/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts
+++ b/apps/sim/app/api/copilot/checkpoints/revert/route.test.ts
@@ -43,7 +43,7 @@ vi.mock('@/lib/workflows/utils', () => ({
   authorizeWorkflowByWorkspacePermission: mockAuthorize,
 }))
 
-vi.mock('@/lib/copilot/chat-lifecycle', () => ({
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
   getAccessibleCopilotChat: mockGetAccessibleCopilotChat,
 }))
 
diff --git a/apps/sim/app/api/copilot/checkpoints/revert/route.ts b/apps/sim/app/api/copilot/checkpoints/revert/route.ts
index dd73477f5ec..b49d21f3841 100644
--- a/apps/sim/app/api/copilot/checkpoints/revert/route.ts
+++ b/apps/sim/app/api/copilot/checkpoints/revert/route.ts
@@ -4,14 +4,14 @@ import { createLogger } from '@sim/logger'
 import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createInternalServerErrorResponse,
   createNotFoundResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 import { isUuidV4 } from '@/executor/constants'
diff --git a/apps/sim/app/api/copilot/checkpoints/route.test.ts b/apps/sim/app/api/copilot/checkpoints/route.test.ts
index eedf688af37..e1b3a1f4e81 100644
--- a/apps/sim/app/api/copilot/checkpoints/route.test.ts
+++ b/apps/sim/app/api/copilot/checkpoints/route.test.ts
@@ -62,7 +62,7 @@ vi.mock('drizzle-orm', () => ({
   desc: vi.fn((field: unknown) => ({ field, type: 'desc' })),
 }))
 
-vi.mock('@/lib/copilot/chat-lifecycle', () => ({
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
   getAccessibleCopilotChat: mockGetAccessibleCopilotChat,
 }))
 
diff --git a/apps/sim/app/api/copilot/checkpoints/route.ts b/apps/sim/app/api/copilot/checkpoints/route.ts
index 58b4cde4bb2..c800e519542 100644
--- a/apps/sim/app/api/copilot/checkpoints/route.ts
+++ b/apps/sim/app/api/copilot/checkpoints/route.ts
@@ -4,14 +4,14 @@ import { createLogger } from '@sim/logger'
 import { and, desc, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
 
 const logger = createLogger('WorkflowCheckpointsAPI')
diff --git a/apps/sim/app/api/copilot/confirm/route.test.ts b/apps/sim/app/api/copilot/confirm/route.test.ts
index 8570d637646..a81e39c2821 100644
--- a/apps/sim/app/api/copilot/confirm/route.test.ts
+++ b/apps/sim/app/api/copilot/confirm/route.test.ts
@@ -38,7 +38,7 @@ const {
   publishToolConfirmation: vi.fn(),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
@@ -54,7 +54,7 @@ vi.mock('@/lib/copilot/async-runs/repository', () => ({
   completeAsyncToolCall,
 }))
 
-vi.mock('@/lib/copilot/orchestrator/persistence', () => ({
+vi.mock('@/lib/copilot/persistence/tool-confirm', () => ({
   publishToolConfirmation,
 }))
 
@@ -161,27 +161,33 @@ describe('Copilot Confirm API Route', () => {
     )
   })
 
-  it('uses upsertAsyncToolCall for non-terminal confirmations', async () => {
+  it('accepts primitive terminal confirmation data', async () => {
     const response = await POST(
       createMockPostRequest({
         toolCallId: 'tool-call-123',
-        status: 'accepted',
+        status: 'success',
+        message: 'Tool executed successfully',
+        data: 'done',
       })
     )
 
     expect(response.status).toBe(200)
-    expect(upsertAsyncToolCall).toHaveBeenCalledWith({
-      runId: 'run-1',
-      checkpointId: 'checkpoint-1',
+    expect(completeAsyncToolCall).toHaveBeenCalledWith({
       toolCallId: 'tool-call-123',
-      toolName: 'client_tool',
-      args: { foo: 'bar' },
-      status: 'pending',
+      status: 'completed',
+      result: 'done',
+      error: null,
     })
-    expect(completeAsyncToolCall).not.toHaveBeenCalled()
+    expect(publishToolConfirmation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        toolCallId: 'tool-call-123',
+        status: 'success',
+        data: 'done',
+      })
+    )
   })
 
-  it('publishes confirmation after a durable non-terminal update', async () => {
+  it('keeps background as a live pending detach confirmation', async () => {
     const response = await POST(
       createMockPostRequest({
         toolCallId: 'tool-call-123',
@@ -190,14 +196,8 @@ describe('Copilot Confirm API Route', () => {
     )
 
     expect(response.status).toBe(200)
-    expect(upsertAsyncToolCall).toHaveBeenCalledWith({
-      runId: 'run-1',
-      checkpointId: 'checkpoint-1',
-      toolCallId: 'tool-call-123',
-      toolName: 'client_tool',
-      args: { foo: 'bar' },
-      status: 'pending',
-    })
+    expect(upsertAsyncToolCall).not.toHaveBeenCalled()
+    expect(completeAsyncToolCall).not.toHaveBeenCalled()
     expect(publishToolConfirmation).toHaveBeenCalledWith(
       expect.objectContaining({
         toolCallId: 'tool-call-123',
@@ -206,6 +206,32 @@ describe('Copilot Confirm API Route', () => {
     )
   })
 
+  it('rejects unsupported accepted and rejected confirmation statuses', async () => {
+    const acceptedResponse = await POST(
+      createMockPostRequest({
+        toolCallId: 'tool-call-123',
+        status: 'accepted',
+      })
+    )
+
+    expect(acceptedResponse.status).toBe(400)
+    expect(await acceptedResponse.json()).toEqual({
+      error: 'Invalid request data: Invalid notification status',
+    })
+
+    const rejectedResponse = await POST(
+      createMockPostRequest({
+        toolCallId: 'tool-call-123',
+        status: 'rejected',
+      })
+    )
+
+    expect(rejectedResponse.status).toBe(400)
+    expect(await rejectedResponse.json()).toEqual({
+      error: 'Invalid request data: Invalid notification status',
+    })
+  })
+
   it('returns 400 when the durable write fails before publish', async () => {
     completeAsyncToolCall.mockRejectedValueOnce(new Error('db down'))
 
diff --git a/apps/sim/app/api/copilot/confirm/route.ts b/apps/sim/app/api/copilot/confirm/route.ts
index bf154487f05..83aea100f6b 100644
--- a/apps/sim/app/api/copilot/confirm/route.ts
+++ b/apps/sim/app/api/copilot/confirm/route.ts
@@ -1,13 +1,19 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
+import {
+  ASYNC_TOOL_CONFIRMATION_STATUS,
+  ASYNC_TOOL_STATUS,
+  type AsyncCompletionData,
+  type AsyncConfirmationStatus,
+} from '@/lib/copilot/async-runs/lifecycle'
 import {
   completeAsyncToolCall,
   getAsyncToolCall,
   getRunSegment,
   upsertAsyncToolCall,
 } from '@/lib/copilot/async-runs/repository'
-import { publishToolConfirmation } from '@/lib/copilot/orchestrator/persistence'
+import { publishToolConfirmation } from '@/lib/copilot/persistence/tool-confirm'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
@@ -15,44 +21,62 @@ import {
   createNotFoundResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-  type NotificationStatus,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 
 const logger = createLogger('CopilotConfirmAPI')
 
 // Schema for confirmation request
 const ConfirmationSchema = z.object({
   toolCallId: z.string().min(1, 'Tool call ID is required'),
-  status: z.enum(['success', 'error', 'accepted', 'rejected', 'background', 'cancelled'] as const, {
-    errorMap: () => ({ message: 'Invalid notification status' }),
-  }),
+  status: z.enum(
+    Object.values(ASYNC_TOOL_CONFIRMATION_STATUS) as [
+      AsyncConfirmationStatus,
+      ...AsyncConfirmationStatus[],
+    ],
+    {
+      errorMap: () => ({ message: 'Invalid notification status' }),
+    }
+  ),
   message: z.string().optional(),
-  data: z.record(z.unknown()).optional(),
+  data: z.unknown().optional(),
 })
 
 /**
- * Persist the durable tool status, then publish a wakeup event.
+ * Persist terminal durable tool status, then publish a wakeup event.
+ *
+ * `background` remains a live detach signal in the current browser workflow
+ * runtime, so it should not rewrite the durable async row.
  */
 async function updateToolCallStatus(
   existing: NonNullable<Awaited<ReturnType<typeof getAsyncToolCall>>>,
-  status: NotificationStatus,
+  status: AsyncConfirmationStatus,
   message?: string,
-  data?: Record<string, unknown>
+  data?: AsyncCompletionData
 ): Promise<boolean> {
   const toolCallId = existing.toolCallId
+  if (status === ASYNC_TOOL_CONFIRMATION_STATUS.background) {
+    publishToolConfirmation({
+      toolCallId,
+      status,
+      message: message || undefined,
+      timestamp: new Date().toISOString(),
+      data,
+    })
+    return true
+  }
   const durableStatus =
     status === 'success'
-      ? 'completed'
+      ? ASYNC_TOOL_STATUS.completed
       : status === 'cancelled'
-        ? 'cancelled'
-        : status === 'error' || status === 'rejected'
-          ? 'failed'
-          : 'pending'
+        ? ASYNC_TOOL_STATUS.cancelled
+        : status === 'error'
+          ? ASYNC_TOOL_STATUS.failed
+          : ASYNC_TOOL_STATUS.pending
   try {
     if (
-      durableStatus === 'completed' ||
-      durableStatus === 'failed' ||
-      durableStatus === 'cancelled'
+      durableStatus === ASYNC_TOOL_STATUS.completed ||
+      durableStatus === ASYNC_TOOL_STATUS.failed ||
+      durableStatus === ASYNC_TOOL_STATUS.cancelled
     ) {
       await completeAsyncToolCall({
         toolCallId,
@@ -70,12 +94,11 @@ async function updateToolCallStatus(
         status: durableStatus,
       })
     }
-    const timestamp = new Date().toISOString()
     publishToolConfirmation({
       toolCallId,
       status,
       message: message || undefined,
-      timestamp,
+      timestamp: new Date().toISOString(),
       data,
     })
     return true
@@ -91,7 +114,7 @@ async function updateToolCallStatus(
 
 /**
  * POST /api/copilot/confirm
- * Update tool call status (Accept/Reject)
+ * Accept client tool completion or detach confirmations.
  */
 export async function POST(req: NextRequest) {
   const tracker = createRequestTracker()
@@ -107,13 +130,25 @@ export async function POST(req: NextRequest) {
 
     const body = await req.json()
     const { toolCallId, status, message, data } = ConfirmationSchema.parse(body)
-    const existing = await getAsyncToolCall(toolCallId).catch(() => null)
+    const existing = await getAsyncToolCall(toolCallId).catch((err) => {
+      logger.warn('Failed to fetch async tool call', {
+        toolCallId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return null
+    })
 
     if (!existing) {
       return createNotFoundResponse('Tool call not found')
     }
 
-    const run = await getRunSegment(existing.runId).catch(() => null)
+    const run = await getRunSegment(existing.runId).catch((err) => {
+      logger.warn('Failed to fetch run segment', {
+        runId: existing.runId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return null
+    })
     if (!run) {
       return createNotFoundResponse('Tool call run not found')
     }
diff --git a/apps/sim/app/api/copilot/credentials/route.ts b/apps/sim/app/api/copilot/credentials/route.ts
index 2f764429d74..82d031c9e64 100644
--- a/apps/sim/app/api/copilot/credentials/route.ts
+++ b/apps/sim/app/api/copilot/credentials/route.ts
@@ -1,5 +1,5 @@
 import { type NextRequest, NextResponse } from 'next/server'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
 import { routeExecution } from '@/lib/copilot/tools/server/router'
 
 /**
diff --git a/apps/sim/app/api/copilot/feedback/route.test.ts b/apps/sim/app/api/copilot/feedback/route.test.ts
index f74aecf77a7..3f3a28598a6 100644
--- a/apps/sim/app/api/copilot/feedback/route.test.ts
+++ b/apps/sim/app/api/copilot/feedback/route.test.ts
@@ -57,7 +57,7 @@ vi.mock('drizzle-orm', () => ({
   eq: vi.fn((field: unknown, value: unknown) => ({ field, value, type: 'eq' })),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly: mockAuthenticate,
   createUnauthorizedResponse: mockCreateUnauthorizedResponse,
   createBadRequestResponse: mockCreateBadRequestResponse,
diff --git a/apps/sim/app/api/copilot/feedback/route.ts b/apps/sim/app/api/copilot/feedback/route.ts
index 92abaa1c3e9..175bc995d50 100644
--- a/apps/sim/app/api/copilot/feedback/route.ts
+++ b/apps/sim/app/api/copilot/feedback/route.ts
@@ -10,7 +10,7 @@ import {
   createInternalServerErrorResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { captureServerEvent } from '@/lib/posthog/server'
 
 const logger = createLogger('CopilotFeedbackAPI')
diff --git a/apps/sim/app/api/copilot/models/route.ts b/apps/sim/app/api/copilot/models/route.ts
index d1773797453..7e23e38df69 100644
--- a/apps/sim/app/api/copilot/models/route.ts
+++ b/apps/sim/app/api/copilot/models/route.ts
@@ -1,8 +1,14 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request-helpers'
-import type { AvailableModel } from '@/lib/copilot/types'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
+
+interface AvailableModel {
+  id: string
+  friendlyName: string
+  provider: string
+}
+
 import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotModelsAPI')
diff --git a/apps/sim/app/api/copilot/stats/route.test.ts b/apps/sim/app/api/copilot/stats/route.test.ts
index 176a97eb371..ca6e97704f0 100644
--- a/apps/sim/app/api/copilot/stats/route.test.ts
+++ b/apps/sim/app/api/copilot/stats/route.test.ts
@@ -23,7 +23,7 @@ const {
   mockFetch: vi.fn(),
 }))
 
-vi.mock('@/lib/copilot/request-helpers', () => ({
+vi.mock('@/lib/copilot/request/http', () => ({
   authenticateCopilotRequestSessionOnly: mockAuthenticateCopilotRequestSessionOnly,
   createUnauthorizedResponse: mockCreateUnauthorizedResponse,
   createBadRequestResponse: mockCreateBadRequestResponse,
diff --git a/apps/sim/app/api/copilot/stats/route.ts b/apps/sim/app/api/copilot/stats/route.ts
index 493f6e4ec90..75ed6d096b1 100644
--- a/apps/sim/app/api/copilot/stats/route.ts
+++ b/apps/sim/app/api/copilot/stats/route.ts
@@ -7,7 +7,7 @@ import {
   createInternalServerErrorResponse,
   createRequestTracker,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { env } from '@/lib/core/config/env'
 
 const BodySchema = z.object({
diff --git a/apps/sim/app/api/copilot/training/examples/route.ts b/apps/sim/app/api/copilot/training/examples/route.ts
index 934ce256875..a9318940b91 100644
--- a/apps/sim/app/api/copilot/training/examples/route.ts
+++ b/apps/sim/app/api/copilot/training/examples/route.ts
@@ -4,7 +4,7 @@ import { z } from 'zod'
 import {
   authenticateCopilotRequestSessionOnly,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotTrainingExamplesAPI')
diff --git a/apps/sim/app/api/copilot/training/route.ts b/apps/sim/app/api/copilot/training/route.ts
index e6e58f59bb0..e30918b8212 100644
--- a/apps/sim/app/api/copilot/training/route.ts
+++ b/apps/sim/app/api/copilot/training/route.ts
@@ -4,7 +4,7 @@ import { z } from 'zod'
 import {
   authenticateCopilotRequestSessionOnly,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
+} from '@/lib/copilot/request/http'
 import { env } from '@/lib/core/config/env'
 
 const logger = createLogger('CopilotTrainingAPI')
diff --git a/apps/sim/app/api/files/serve/[...path]/route.test.ts b/apps/sim/app/api/files/serve/[...path]/route.test.ts
index bc5b35647c0..3c0c1fa7f6c 100644
--- a/apps/sim/app/api/files/serve/[...path]/route.test.ts
+++ b/apps/sim/app/api/files/serve/[...path]/route.test.ts
@@ -75,6 +75,16 @@ vi.mock('@/lib/uploads/utils/file-utils', () => ({
 
 vi.mock('@/lib/uploads/setup.server', () => ({}))
 
+vi.mock('@/lib/execution/doc-vm', () => ({
+  generatePdfFromCode: vi.fn().mockResolvedValue(Buffer.from('%PDF-compiled')),
+  generateDocxFromCode: vi.fn().mockResolvedValue(Buffer.from('PK\x03\x04compiled')),
+  generatePptxFromCode: vi.fn().mockResolvedValue(Buffer.from('PK\x03\x04compiled')),
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  parseWorkspaceFileKey: vi.fn().mockReturnValue(undefined),
+}))
+
 vi.mock('@/app/api/files/utils', () => ({
   FileNotFoundError,
   createFileResponse: mockCreateFileResponse,
diff --git a/apps/sim/app/api/files/serve/[...path]/route.ts b/apps/sim/app/api/files/serve/[...path]/route.ts
index bc14086395a..0f15198c328 100644
--- a/apps/sim/app/api/files/serve/[...path]/route.ts
+++ b/apps/sim/app/api/files/serve/[...path]/route.ts
@@ -4,7 +4,11 @@ import { createLogger } from '@sim/logger'
 import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
 import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
-import { generatePptxFromCode } from '@/lib/execution/pptx-vm'
+import {
+  generateDocxFromCode,
+  generatePdfFromCode,
+  generatePptxFromCode,
+} from '@/lib/execution/doc-vm'
 import { CopilotFiles, isUsingCloudStorage } from '@/lib/uploads'
 import type { StorageContext } from '@/lib/uploads/config'
 import { parseWorkspaceFileKey } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
@@ -22,47 +26,73 @@ import {
 const logger = createLogger('FilesServeAPI')
 
 const ZIP_MAGIC = Buffer.from([0x50, 0x4b, 0x03, 0x04])
+const PDF_MAGIC = Buffer.from([0x25, 0x50, 0x44, 0x46, 0x2d]) // %PDF-
+
+interface CompilableFormat {
+  magic: Buffer
+  compile: (code: string, workspaceId: string) => Promise<Buffer>
+  contentType: string
+}
+
+const COMPILABLE_FORMATS: Record<string, CompilableFormat> = {
+  '.pptx': {
+    magic: ZIP_MAGIC,
+    compile: generatePptxFromCode,
+    contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  },
+  '.docx': {
+    magic: ZIP_MAGIC,
+    compile: generateDocxFromCode,
+    contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  },
+  '.pdf': {
+    magic: PDF_MAGIC,
+    compile: generatePdfFromCode,
+    contentType: 'application/pdf',
+  },
+}
 
-const MAX_COMPILED_PPTX_CACHE = 10
-const compiledPptxCache = new Map<string, Buffer>()
+const MAX_COMPILED_DOC_CACHE = 10
+const compiledDocCache = new Map<string, Buffer>()
 
 function compiledCacheSet(key: string, buffer: Buffer): void {
-  if (compiledPptxCache.size >= MAX_COMPILED_PPTX_CACHE) {
-    compiledPptxCache.delete(compiledPptxCache.keys().next().value as string)
+  if (compiledDocCache.size >= MAX_COMPILED_DOC_CACHE) {
+    compiledDocCache.delete(compiledDocCache.keys().next().value as string)
   }
-  compiledPptxCache.set(key, buffer)
+  compiledDocCache.set(key, buffer)
 }
 
-async function compilePptxIfNeeded(
+async function compileDocumentIfNeeded(
   buffer: Buffer,
   filename: string,
   workspaceId?: string,
   raw?: boolean
 ): Promise<{ buffer: Buffer; contentType: string }> {
-  const isPptx = filename.toLowerCase().endsWith('.pptx')
-  if (raw || !isPptx || buffer.subarray(0, 4).equals(ZIP_MAGIC)) {
+  if (raw) return { buffer, contentType: getContentType(filename) }
+
+  const ext = filename.slice(filename.lastIndexOf('.')).toLowerCase()
+  const format = COMPILABLE_FORMATS[ext]
+  if (!format) return { buffer, contentType: getContentType(filename) }
+
+  const magicLen = format.magic.length
+  if (buffer.length >= magicLen && buffer.subarray(0, magicLen).equals(format.magic)) {
     return { buffer, contentType: getContentType(filename) }
   }
 
   const code = buffer.toString('utf-8')
   const cacheKey = createHash('sha256')
+    .update(ext)
     .update(code)
     .update(workspaceId ?? '')
     .digest('hex')
-  const cached = compiledPptxCache.get(cacheKey)
+  const cached = compiledDocCache.get(cacheKey)
   if (cached) {
-    return {
-      buffer: cached,
-      contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-    }
+    return { buffer: cached, contentType: format.contentType }
   }
 
-  const compiled = await generatePptxFromCode(code, workspaceId || '')
+  const compiled = await format.compile(code, workspaceId || '')
   compiledCacheSet(cacheKey, compiled)
-  return {
-    buffer: compiled,
-    contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  }
+  return { buffer: compiled, contentType: format.contentType }
 }
 
 const STORAGE_KEY_PREFIX_RE = /^\d{13}-[a-z0-9]{7}-/
@@ -169,7 +199,7 @@ async function handleLocalFile(
     const segment = filename.split('/').pop() || filename
     const displayName = stripStorageKeyPrefix(segment)
     const workspaceId = getWorkspaceIdForCompile(filename)
-    const { buffer: fileBuffer, contentType } = await compilePptxIfNeeded(
+    const { buffer: fileBuffer, contentType } = await compileDocumentIfNeeded(
       rawBuffer,
       displayName,
       workspaceId,
@@ -226,7 +256,7 @@ async function handleCloudProxy(
     const segment = cloudKey.split('/').pop() || 'download'
     const displayName = stripStorageKeyPrefix(segment)
     const workspaceId = getWorkspaceIdForCompile(cloudKey)
-    const { buffer: fileBuffer, contentType } = await compilePptxIfNeeded(
+    const { buffer: fileBuffer, contentType } = await compileDocumentIfNeeded(
       rawBuffer,
       displayName,
       workspaceId,
diff --git a/apps/sim/app/api/function/execute/route.test.ts b/apps/sim/app/api/function/execute/route.test.ts
index 02db5236704..766bbb88fad 100644
--- a/apps/sim/app/api/function/execute/route.test.ts
+++ b/apps/sim/app/api/function/execute/route.test.ts
@@ -24,6 +24,27 @@ vi.mock('@/lib/auth/hybrid', () => ({
 
 vi.mock('@/lib/execution/e2b', () => ({
   executeInE2B: mockExecuteInE2B,
+  executeShellInE2B: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/tools/files', () => ({
+  FORMAT_TO_CONTENT_TYPE: {
+    json: 'application/json',
+    csv: 'text/csv',
+    txt: 'text/plain',
+    md: 'text/markdown',
+    html: 'text/html',
+  },
+  normalizeOutputWorkspaceFileName: vi.fn((p: string) => p.replace(/^files\//, '')),
+  resolveOutputFormat: vi.fn(() => 'json'),
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  uploadWorkspaceFile: vi.fn(),
+}))
+
+vi.mock('@/lib/workflows/utils', () => ({
+  getWorkflowById: vi.fn(),
 }))
 
 vi.mock('@/lib/core/config/feature-flags', () => ({
@@ -32,6 +53,7 @@ vi.mock('@/lib/core/config/feature-flags', () => ({
   isProd: false,
   isDev: false,
   isTest: true,
+  isEmailVerificationEnabled: false,
 }))
 
 import { validateProxyUrl } from '@/lib/core/security/input-validation'
diff --git a/apps/sim/app/api/function/execute/route.ts b/apps/sim/app/api/function/execute/route.ts
index 24e992401b7..2328bf11fbb 100644
--- a/apps/sim/app/api/function/execute/route.ts
+++ b/apps/sim/app/api/function/execute/route.ts
@@ -1,11 +1,18 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { checkInternalAuth } from '@/lib/auth/hybrid'
+import {
+  FORMAT_TO_CONTENT_TYPE,
+  normalizeOutputWorkspaceFileName,
+  resolveOutputFormat,
+} from '@/lib/copilot/request/tools/files'
 import { isE2bEnabled } from '@/lib/core/config/feature-flags'
 import { generateRequestId } from '@/lib/core/utils/request'
-import { executeInE2B } from '@/lib/execution/e2b'
+import { executeInE2B, executeShellInE2B } from '@/lib/execution/e2b'
 import { executeInIsolatedVM } from '@/lib/execution/isolated-vm'
 import { CodeLanguage, DEFAULT_CODE_LANGUAGE, isValidCodeLanguage } from '@/lib/execution/languages'
+import { uploadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { getWorkflowById } from '@/lib/workflows/utils'
 import { escapeRegExp, normalizeName, REFERENCE } from '@/executor/constants'
 import { type OutputSchema, resolveBlockReference } from '@/executor/utils/block-reference'
 import { formatLiteralForCode } from '@/executor/utils/code-formatting'
@@ -580,6 +587,107 @@ function cleanStdout(stdout: string): string {
   return stdout
 }
 
+async function maybeExportSandboxFileToWorkspace(args: {
+  authUserId: string
+  workflowId?: string
+  workspaceId?: string
+  outputPath?: string
+  outputFormat?: string
+  outputMimeType?: string
+  outputSandboxPath?: string
+  exportedFileContent?: string
+  stdout: string
+  executionTime: number
+}) {
+  const {
+    authUserId,
+    workflowId,
+    workspaceId,
+    outputPath,
+    outputFormat,
+    outputMimeType,
+    outputSandboxPath,
+    exportedFileContent,
+    stdout,
+    executionTime,
+  } = args
+
+  if (!outputSandboxPath) return null
+
+  if (!outputPath) {
+    return NextResponse.json(
+      {
+        success: false,
+        error:
+          'outputSandboxPath requires outputPath. Set outputPath to the destination workspace file, e.g. "files/result.csv".',
+        output: { result: null, stdout: cleanStdout(stdout), executionTime },
+      },
+      { status: 400 }
+    )
+  }
+
+  const resolvedWorkspaceId =
+    workspaceId || (workflowId ? (await getWorkflowById(workflowId))?.workspaceId : undefined)
+
+  if (!resolvedWorkspaceId) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: 'Workspace context required to save sandbox file to workspace',
+        output: { result: null, stdout: cleanStdout(stdout), executionTime },
+      },
+      { status: 400 }
+    )
+  }
+
+  if (exportedFileContent === undefined) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: `Sandbox file "${outputSandboxPath}" was not found or could not be read`,
+        output: { result: null, stdout: cleanStdout(stdout), executionTime },
+      },
+      { status: 500 }
+    )
+  }
+
+  const fileName = normalizeOutputWorkspaceFileName(outputPath)
+
+  const TEXT_MIMES = new Set(Object.values(FORMAT_TO_CONTENT_TYPE))
+  const resolvedMimeType =
+    outputMimeType ||
+    FORMAT_TO_CONTENT_TYPE[resolveOutputFormat(fileName, outputFormat)] ||
+    'application/octet-stream'
+  const isBinary = !TEXT_MIMES.has(resolvedMimeType)
+  const fileBuffer = isBinary
+    ? Buffer.from(exportedFileContent, 'base64')
+    : Buffer.from(exportedFileContent, 'utf-8')
+
+  const uploaded = await uploadWorkspaceFile(
+    resolvedWorkspaceId,
+    authUserId,
+    fileBuffer,
+    fileName,
+    resolvedMimeType
+  )
+
+  return NextResponse.json({
+    success: true,
+    output: {
+      result: {
+        message: `Sandbox file exported to files/${fileName}`,
+        fileId: uploaded.id,
+        fileName,
+        downloadUrl: uploaded.url,
+        sandboxPath: outputSandboxPath,
+      },
+      stdout: cleanStdout(stdout),
+      executionTime,
+    },
+    resources: [{ type: 'file', id: uploaded.id, title: fileName }],
+  })
+}
+
 export async function POST(req: NextRequest) {
   const requestId = generateRequestId()
   const startTime = Date.now()
@@ -603,12 +711,17 @@ export async function POST(req: NextRequest) {
       params = {},
       timeout = DEFAULT_EXECUTION_TIMEOUT_MS,
       language = DEFAULT_CODE_LANGUAGE,
+      outputPath,
+      outputFormat,
+      outputMimeType,
+      outputSandboxPath,
       envVars = {},
       blockData = {},
       blockNameMapping = {},
       blockOutputSchemas = {},
       workflowVariables = {},
       workflowId,
+      workspaceId,
       isCustomTool = false,
       _sandboxFiles,
     } = body
@@ -626,18 +739,25 @@ export async function POST(req: NextRequest) {
 
     const lang = isValidCodeLanguage(language) ? language : DEFAULT_CODE_LANGUAGE
 
-    const codeResolution = resolveCodeVariables(
-      code,
-      executionParams,
-      envVars,
-      blockData,
-      blockNameMapping,
-      blockOutputSchemas,
-      workflowVariables,
-      lang
-    )
-    resolvedCode = codeResolution.resolvedCode
-    const contextVariables = codeResolution.contextVariables
+    let contextVariables: Record<string, unknown> = {}
+    if (lang === CodeLanguage.Shell) {
+      // For shell, env vars are injected as OS env vars via shellEnvs.
+      // Replace {{VAR}} placeholders with $VAR so the shell can access them natively.
+      resolvedCode = code.replace(/\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}/g, '$$$1')
+    } else {
+      const codeResolution = resolveCodeVariables(
+        code,
+        executionParams,
+        envVars,
+        blockData,
+        blockNameMapping,
+        blockOutputSchemas,
+        workflowVariables,
+        lang
+      )
+      resolvedCode = codeResolution.resolvedCode
+      contextVariables = codeResolution.contextVariables
+    }
 
     let jsImports = ''
     let jsRemainingCode = resolvedCode
@@ -652,6 +772,83 @@ export async function POST(req: NextRequest) {
       hasImports = jsImports.trim().length > 0 || hasRequireStatements
     }
 
+    if (lang === CodeLanguage.Shell) {
+      if (!isE2bEnabled) {
+        throw new Error(
+          'Shell execution requires E2B to be enabled. Please contact your administrator to enable E2B.'
+        )
+      }
+
+      const shellEnvs: Record<string, string> = {}
+      for (const [k, v] of Object.entries(envVars)) {
+        shellEnvs[k] = String(v)
+      }
+      for (const [k, v] of Object.entries(contextVariables)) {
+        shellEnvs[k] = String(v)
+      }
+
+      logger.info(`[${requestId}] E2B shell execution`, {
+        enabled: isE2bEnabled,
+        hasApiKey: Boolean(process.env.E2B_API_KEY),
+        envVarCount: Object.keys(shellEnvs).length,
+      })
+
+      const execStart = Date.now()
+      const {
+        result: shellResult,
+        stdout: shellStdout,
+        sandboxId,
+        error: shellError,
+        exportedFileContent,
+      } = await executeShellInE2B({
+        code: resolvedCode,
+        envs: shellEnvs,
+        timeoutMs: timeout,
+        sandboxFiles: _sandboxFiles,
+        outputSandboxPath,
+      })
+      const executionTime = Date.now() - execStart
+
+      logger.info(`[${requestId}] E2B shell sandbox`, {
+        sandboxId,
+        stdoutPreview: shellStdout?.slice(0, 200),
+        error: shellError,
+        executionTime,
+      })
+
+      if (shellError) {
+        return NextResponse.json(
+          {
+            success: false,
+            error: shellError,
+            output: { result: null, stdout: cleanStdout(shellStdout), executionTime },
+          },
+          { status: 500 }
+        )
+      }
+
+      if (outputSandboxPath) {
+        const fileExportResponse = await maybeExportSandboxFileToWorkspace({
+          authUserId: auth.userId,
+          workflowId,
+          workspaceId,
+          outputPath,
+          outputFormat,
+          outputMimeType,
+          outputSandboxPath,
+          exportedFileContent,
+          stdout: shellStdout,
+          executionTime,
+        })
+        if (fileExportResponse) return fileExportResponse
+      }
+
+      return NextResponse.json({
+        success: true,
+        output: { result: shellResult ?? null, stdout: cleanStdout(shellStdout), executionTime },
+      })
+    }
+
     if (lang === CodeLanguage.Python && !isE2bEnabled) {
       throw new Error(
         'Python execution requires E2B to be enabled. Please contact your administrator to enable E2B, or use JavaScript instead.'
@@ -719,11 +916,13 @@ export async function POST(req: NextRequest) {
           stdout: e2bStdout,
           sandboxId,
           error: e2bError,
+          exportedFileContent,
         } = await executeInE2B({
           code: codeForE2B,
           language: CodeLanguage.JavaScript,
           timeoutMs: timeout,
           sandboxFiles: _sandboxFiles,
+          outputSandboxPath,
         })
         const executionTime = Date.now() - execStart
         stdout += e2bStdout
@@ -752,6 +951,22 @@ export async function POST(req: NextRequest) {
           )
         }
 
+        if (outputSandboxPath) {
+          const fileExportResponse = await maybeExportSandboxFileToWorkspace({
+            authUserId: auth.userId,
+            workflowId,
+            workspaceId,
+            outputPath,
+            outputFormat,
+            outputMimeType,
+            outputSandboxPath,
+            exportedFileContent,
+            stdout,
+            executionTime,
+          })
+          if (fileExportResponse) return fileExportResponse
+        }
+
         return NextResponse.json({
           success: true,
           output: { result: e2bResult ?? null, stdout: cleanStdout(stdout), executionTime },
@@ -783,11 +998,13 @@ export async function POST(req: NextRequest) {
         stdout: e2bStdout,
         sandboxId,
         error: e2bError,
+        exportedFileContent,
       } = await executeInE2B({
         code: codeForE2B,
         language: CodeLanguage.Python,
         timeoutMs: timeout,
         sandboxFiles: _sandboxFiles,
+        outputSandboxPath,
       })
       const executionTime = Date.now() - execStart
       stdout += e2bStdout
@@ -816,6 +1033,22 @@ export async function POST(req: NextRequest) {
         )
       }
 
+      if (outputSandboxPath) {
+        const fileExportResponse = await maybeExportSandboxFileToWorkspace({
+          authUserId: auth.userId,
+          workflowId,
+          workspaceId,
+          outputPath,
+          outputFormat,
+          outputMimeType,
+          outputSandboxPath,
+          exportedFileContent,
+          stdout,
+          executionTime,
+        })
+        if (fileExportResponse) return fileExportResponse
+      }
+
       return NextResponse.json({
         success: true,
         output: { result: e2bResult ?? null, stdout: cleanStdout(stdout), executionTime },
diff --git a/apps/sim/app/api/jobs/[jobId]/route.test.ts b/apps/sim/app/api/jobs/[jobId]/route.test.ts
index 050c0bee2c5..6ebce09fa67 100644
--- a/apps/sim/app/api/jobs/[jobId]/route.test.ts
+++ b/apps/sim/app/api/jobs/[jobId]/route.test.ts
@@ -6,16 +6,16 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const {
   mockCheckHybridAuth,
-  mockGetDispatchJobRecord,
   mockGetJobQueue,
   mockVerifyWorkflowAccess,
   mockGetWorkflowById,
+  mockGetJob,
 } = vi.hoisted(() => ({
   mockCheckHybridAuth: vi.fn(),
-  mockGetDispatchJobRecord: vi.fn(),
   mockGetJobQueue: vi.fn(),
   mockVerifyWorkflowAccess: vi.fn(),
   mockGetWorkflowById: vi.fn(),
+  mockGetJob: vi.fn(),
 }))
 
 vi.mock('@sim/logger', () => ({
@@ -32,19 +32,9 @@ vi.mock('@/lib/auth/hybrid', () => ({
 }))
 
 vi.mock('@/lib/core/async-jobs', () => ({
-  JOB_STATUS: {
-    PENDING: 'pending',
-    PROCESSING: 'processing',
-    COMPLETED: 'completed',
-    FAILED: 'failed',
-  },
   getJobQueue: mockGetJobQueue,
 }))
 
-vi.mock('@/lib/core/workspace-dispatch/store', () => ({
-  getDispatchJobRecord: mockGetDispatchJobRecord,
-}))
-
 vi.mock('@/lib/core/utils/request', () => ({
   generateRequestId: vi.fn().mockReturnValue('request-1'),
 }))
@@ -85,71 +75,51 @@ describe('GET /api/jobs/[jobId]', () => {
     })
 
     mockGetJobQueue.mockResolvedValue({
-      getJob: vi.fn().mockResolvedValue(null),
+      getJob: mockGetJob,
     })
   })
 
-  it('returns dispatcher-aware waiting status with metadata', async () => {
-    mockGetDispatchJobRecord.mockResolvedValue({
-      id: 'dispatch-1',
-      workspaceId: 'workspace-1',
-      lane: 'runtime',
-      queueName: 'workflow-execution',
-      bullmqJobName: 'workflow-execution',
-      bullmqPayload: {},
+  it('returns job status with metadata', async () => {
+    mockGetJob.mockResolvedValue({
+      id: 'job-1',
+      status: 'pending',
       metadata: {
         workflowId: 'workflow-1',
       },
-      priority: 10,
-      status: 'waiting',
-      createdAt: 1000,
-      admittedAt: 2000,
     })
 
     const response = await GET(createMockRequest(), {
-      params: Promise.resolve({ jobId: 'dispatch-1' }),
+      params: Promise.resolve({ jobId: 'job-1' }),
     })
     const body = await response.json()
 
     expect(response.status).toBe(200)
-    expect(body.status).toBe('waiting')
-    expect(body.metadata.queueName).toBe('workflow-execution')
-    expect(body.metadata.lane).toBe('runtime')
-    expect(body.metadata.workspaceId).toBe('workspace-1')
+    expect(body.status).toBe('pending')
+    expect(body.metadata.workflowId).toBe('workflow-1')
   })
 
-  it('returns completed output from dispatch state', async () => {
-    mockGetDispatchJobRecord.mockResolvedValue({
-      id: 'dispatch-2',
-      workspaceId: 'workspace-1',
-      lane: 'interactive',
-      queueName: 'workflow-execution',
-      bullmqJobName: 'direct-workflow-execution',
-      bullmqPayload: {},
+  it('returns completed output from job', async () => {
+    mockGetJob.mockResolvedValue({
+      id: 'job-2',
+      status: 'completed',
       metadata: {
         workflowId: 'workflow-1',
       },
-      priority: 1,
-      status: 'completed',
-      createdAt: 1000,
-      startedAt: 2000,
-      completedAt: 7000,
       output: { success: true },
     })
 
     const response = await GET(createMockRequest(), {
-      params: Promise.resolve({ jobId: 'dispatch-2' }),
+      params: Promise.resolve({ jobId: 'job-2' }),
     })
     const body = await response.json()
 
     expect(response.status).toBe(200)
     expect(body.status).toBe('completed')
     expect(body.output).toEqual({ success: true })
-    expect(body.metadata.duration).toBe(5000)
   })
 
-  it('returns 404 when neither dispatch nor BullMQ job exists', async () => {
-    mockGetDispatchJobRecord.mockResolvedValue(null)
+  it('returns 404 when job does not exist', async () => {
+    mockGetJob.mockResolvedValue(null)
 
     const response = await GET(createMockRequest(), {
       params: Promise.resolve({ jobId: 'missing-job' }),
diff --git a/apps/sim/app/api/jobs/[jobId]/route.ts b/apps/sim/app/api/jobs/[jobId]/route.ts
index 0ce749fa828..b096d801109 100644
--- a/apps/sim/app/api/jobs/[jobId]/route.ts
+++ b/apps/sim/app/api/jobs/[jobId]/route.ts
@@ -3,8 +3,6 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { checkHybridAuth } from '@/lib/auth/hybrid'
 import { getJobQueue } from '@/lib/core/async-jobs'
 import { generateRequestId } from '@/lib/core/utils/request'
-import { presentDispatchOrJobStatus } from '@/lib/core/workspace-dispatch/status'
-import { getDispatchJobRecord } from '@/lib/core/workspace-dispatch/store'
 import { createErrorResponse } from '@/app/api/workflows/utils'
 
 const logger = createLogger('TaskStatusAPI')
@@ -25,15 +23,14 @@ export async function GET(
 
     const authenticatedUserId = authResult.userId
 
-    const dispatchJob = await getDispatchJobRecord(taskId)
     const jobQueue = await getJobQueue()
-    const job = dispatchJob ? null : await jobQueue.getJob(taskId)
+    const job = await jobQueue.getJob(taskId)
 
-    if (!job && !dispatchJob) {
+    if (!job) {
       return createErrorResponse('Task not found', 404)
     }
 
-    const metadataToCheck = dispatchJob?.metadata ?? job?.metadata
+    const metadataToCheck = job.metadata
 
     if (metadataToCheck?.workflowId) {
       const { verifyWorkflowAccess } = await import('@/socket/middleware/permissions')
@@ -61,25 +58,22 @@ export async function GET(
       return createErrorResponse('Access denied', 403)
     }
 
-    const presented = presentDispatchOrJobStatus(dispatchJob, job)
-    const response: any = {
+    const response: Record<string, unknown> = {
       success: true,
       taskId,
-      status: presented.status,
-      metadata: presented.metadata,
+      status: job.status,
+      metadata: job.metadata,
     }
 
-    if (presented.output !== undefined) response.output = presented.output
-    if (presented.error !== undefined) response.error = presented.error
-    if (presented.estimatedDuration !== undefined) {
-      response.estimatedDuration = presented.estimatedDuration
-    }
+    if (job.output !== undefined) response.output = job.output
+    if (job.error !== undefined) response.error = job.error
 
     return NextResponse.json(response)
-  } catch (error: any) {
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
     logger.error(`[${requestId}] Error fetching task status:`, error)
 
-    if (error.message?.includes('not found') || error.status === 404) {
+    if (errorMessage?.includes('not found')) {
       return createErrorResponse('Task not found', 404)
     }
 
diff --git a/apps/sim/app/api/mcp/copilot/route.ts b/apps/sim/app/api/mcp/copilot/route.ts
index f1377d5ad13..ad72860b3bb 100644
--- a/apps/sim/app/api/mcp/copilot/route.ts
+++ b/apps/sim/app/api/mcp/copilot/route.ts
@@ -17,14 +17,11 @@ import { eq, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { validateOAuthAccessToken } from '@/lib/auth/oauth-token'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
 import { ORCHESTRATION_TIMEOUT_MS, SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import { orchestrateSubagentStream } from '@/lib/copilot/orchestrator/subagent'
-import {
-  executeToolServerSide,
-  prepareExecutionContext,
-} from '@/lib/copilot/orchestrator/tool-executor'
+import { runHeadlessCopilotLifecycle } from '@/lib/copilot/request/lifecycle/headless'
+import { orchestrateSubagentStream } from '@/lib/copilot/request/subagent'
+import { ensureHandlersRegistered, executeTool } from '@/lib/copilot/tool-executor'
+import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
 import { DIRECT_TOOL_DEFS, SUBAGENT_TOOL_DEFS } from '@/lib/copilot/tools/mcp/definitions'
 import { env } from '@/lib/core/config/env'
 import { RateLimiter } from '@/lib/core/rate-limiter'
@@ -125,12 +122,10 @@ Sim is a workflow automation platform. Workflows are visual pipelines of connect
 
 1. \`list_workspaces\` → know where to work
 2. \`create_workflow(name, workspaceId)\` → get a workflowId
-3. \`sim_build(request, workflowId)\` → plan and build in one pass
+3. \`sim_workflow(request, workflowId)\` → plan and build in one pass
 4. \`sim_test(request, workflowId)\` → verify it works
 5. \`sim_deploy("deploy as api", workflowId)\` → make it accessible externally (optional)
 
-For fine-grained control, use \`sim_plan\` → \`sim_edit\` instead of \`sim_build\`. Pass the plan object from sim_plan EXACTLY as-is to sim_edit's context.plan field.
-
 ### Working with Existing Workflows
 
 When the user refers to a workflow by name or description ("the email one", "my Slack bot"):
@@ -148,8 +143,8 @@ When the user refers to a workflow by name or description ("the email one", "my
 ### Key Rules
 
 - You can test workflows immediately after building — deployment is only needed for external access (API, chat, MCP).
-- All copilot tools (build, plan, edit, deploy, test, debug) require workflowId.
-- If the user reports errors → use \`sim_debug\` first, don't guess.
+- All workflow-scoped copilot tools require \`workflowId\`.
+- If the user reports errors, route through \`sim_workflow\` and ask it to reproduce, inspect logs, and fix the issue end to end.
 - Variable syntax: \`<blockname.field>\` for block outputs, \`{{ENV_VAR}}\` for env vars.
 `
 
@@ -645,7 +640,8 @@ async function handleDirectToolCall(
       startTime: Date.now(),
     }
 
-    const result = await executeToolServerSide(toolCall, execContext)
+    ensureHandlersRegistered()
+    const result = await executeTool(toolCall.name, toolCall.params || {}, execContext)
 
     return {
       content: [
@@ -672,7 +668,7 @@ async function handleDirectToolCall(
 
 /**
  * Build mode uses the main chat orchestrator with the 'fast' command instead of
- * the subagent endpoint. In Go, 'build' is not a registered subagent — it's a mode
+ * the subagent endpoint. In Go, 'workflow' is not a registered subagent — it's a mode
  * (ModeFast) on the main chat processor that bypasses subagent orchestration and
  * executes all tools directly.
  */
@@ -728,25 +724,10 @@ async function handleBuildToolCall(
       chatId,
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-    const messageId = requestPayload.messageId as string
-
-    await createRunSegment({
-      id: runId,
-      executionId,
-      chatId,
-      userId,
-      workflowId: resolved.workflowId,
-      streamId: messageId,
-    }).catch(() => {})
-
-    const result = await orchestrateCopilotStream(requestPayload, {
+    const result = await runHeadlessCopilotLifecycle(requestPayload, {
       userId,
       workflowId: resolved.workflowId,
       chatId,
-      executionId,
-      runId,
       goRoute: '/api/mcp',
       autoExecuteTools: true,
       timeout: ORCHESTRATION_TIMEOUT_MS,
@@ -785,7 +766,7 @@ async function handleSubagentToolCall(
   userId: string,
   abortSignal?: AbortSignal
 ): Promise<CallToolResult> {
-  if (toolDef.agentId === 'build') {
+  if (toolDef.agentId === 'workflow') {
     return handleBuildToolCall(args, userId, abortSignal)
   }
 
diff --git a/apps/sim/app/api/mothership/chat/abort/route.ts b/apps/sim/app/api/mothership/chat/abort/route.ts
new file mode 100644
index 00000000000..344d89bfb34
--- /dev/null
+++ b/apps/sim/app/api/mothership/chat/abort/route.ts
@@ -0,0 +1 @@
+export { POST } from '@/app/api/copilot/chat/abort/route'
diff --git a/apps/sim/app/api/mothership/chat/resources/route.ts b/apps/sim/app/api/mothership/chat/resources/route.ts
new file mode 100644
index 00000000000..da747172441
--- /dev/null
+++ b/apps/sim/app/api/mothership/chat/resources/route.ts
@@ -0,0 +1 @@
+export { DELETE, PATCH, POST } from '@/app/api/copilot/chat/resources/route'
diff --git a/apps/sim/app/api/mothership/chat/route.ts b/apps/sim/app/api/mothership/chat/route.ts
index 09dea73a050..596654b186d 100644
--- a/apps/sim/app/api/mothership/chat/route.ts
+++ b/apps/sim/app/api/mothership/chat/route.ts
@@ -1,417 +1,3 @@
-import { db } from '@sim/db'
-import { copilotChats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq, sql } from 'drizzle-orm'
-import { type NextRequest, NextResponse } from 'next/server'
-import { z } from 'zod'
-import { getSession } from '@/lib/auth'
-import { resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
-import { buildCopilotRequestPayload } from '@/lib/copilot/chat-payload'
-import {
-  acquirePendingChatStream,
-  createSSEStream,
-  SSE_RESPONSE_HEADERS,
-} from '@/lib/copilot/chat-streaming'
-import type { OrchestratorResult } from '@/lib/copilot/orchestrator/types'
-import { processContextsServer, resolveActiveResourceContext } from '@/lib/copilot/process-contents'
-import { createRequestTracker, createUnauthorizedResponse } from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { generateWorkspaceContext } from '@/lib/copilot/workspace-context'
-import { generateId } from '@/lib/core/utils/uuid'
-import {
-  assertActiveWorkspaceAccess,
-  getUserEntityPermissions,
-} from '@/lib/workspaces/permissions/utils'
-
-export const maxDuration = 3600
-
-const logger = createLogger('MothershipChatAPI')
-
-const FileAttachmentSchema = z.object({
-  id: z.string(),
-  key: z.string(),
-  filename: z.string(),
-  media_type: z.string(),
-  size: z.number(),
-})
-
-const ResourceAttachmentSchema = z.object({
-  type: z.enum(['workflow', 'table', 'file', 'knowledgebase', 'folder']),
-  id: z.string().min(1),
-  title: z.string().optional(),
-  active: z.boolean().optional(),
-})
-
-const MothershipMessageSchema = z.object({
-  message: z.string().min(1, 'Message is required'),
-  workspaceId: z.string().min(1, 'workspaceId is required'),
-  userMessageId: z.string().optional(),
-  chatId: z.string().optional(),
-  createNewChat: z.boolean().optional().default(false),
-  fileAttachments: z.array(FileAttachmentSchema).optional(),
-  userTimezone: z.string().optional(),
-  resourceAttachments: z.array(ResourceAttachmentSchema).optional(),
-  contexts: z
-    .array(
-      z.object({
-        kind: z.enum([
-          'past_chat',
-          'workflow',
-          'current_workflow',
-          'blocks',
-          'logs',
-          'workflow_block',
-          'knowledge',
-          'templates',
-          'docs',
-          'table',
-          'file',
-          'folder',
-        ]),
-        label: z.string(),
-        chatId: z.string().optional(),
-        workflowId: z.string().optional(),
-        knowledgeId: z.string().optional(),
-        blockId: z.string().optional(),
-        blockIds: z.array(z.string()).optional(),
-        templateId: z.string().optional(),
-        executionId: z.string().optional(),
-        tableId: z.string().optional(),
-        fileId: z.string().optional(),
-        folderId: z.string().optional(),
-      })
-    )
-    .optional(),
-})
-
-/**
- * POST /api/mothership/chat
- * Workspace-scoped chat — no workflowId, proxies to Go /api/mothership.
- */
-export async function POST(req: NextRequest) {
-  const tracker = createRequestTracker()
-  let userMessageIdForLogs: string | undefined
-
-  try {
-    const session = await getSession()
-    if (!session?.user?.id) {
-      return createUnauthorizedResponse()
-    }
-
-    const authenticatedUserId = session.user.id
-    const body = await req.json()
-    const {
-      message,
-      workspaceId,
-      userMessageId: providedMessageId,
-      chatId,
-      createNewChat,
-      fileAttachments,
-      contexts,
-      resourceAttachments,
-      userTimezone,
-    } = MothershipMessageSchema.parse(body)
-
-    const userMessageId = providedMessageId || generateId()
-    userMessageIdForLogs = userMessageId
-    const reqLogger = logger.withMetadata({
-      requestId: tracker.requestId,
-      messageId: userMessageId,
-    })
-
-    reqLogger.info('Received mothership chat start request', {
-      workspaceId,
-      chatId,
-      createNewChat,
-      hasContexts: Array.isArray(contexts) && contexts.length > 0,
-      contextsCount: Array.isArray(contexts) ? contexts.length : 0,
-      hasResourceAttachments: Array.isArray(resourceAttachments) && resourceAttachments.length > 0,
-      resourceAttachmentCount: Array.isArray(resourceAttachments) ? resourceAttachments.length : 0,
-      hasFileAttachments: Array.isArray(fileAttachments) && fileAttachments.length > 0,
-      fileAttachmentCount: Array.isArray(fileAttachments) ? fileAttachments.length : 0,
-    })
-
-    try {
-      await assertActiveWorkspaceAccess(workspaceId, authenticatedUserId)
-    } catch {
-      return NextResponse.json({ error: 'Workspace not found or access denied' }, { status: 403 })
-    }
-
-    let currentChat: any = null
-    let conversationHistory: any[] = []
-    let actualChatId = chatId
-
-    if (chatId || createNewChat) {
-      const chatResult = await resolveOrCreateChat({
-        chatId,
-        userId: authenticatedUserId,
-        workspaceId,
-        model: 'claude-opus-4-6',
-        type: 'mothership',
-      })
-      currentChat = chatResult.chat
-      actualChatId = chatResult.chatId || chatId
-      conversationHistory = Array.isArray(chatResult.conversationHistory)
-        ? chatResult.conversationHistory
-        : []
-
-      if (chatId && !currentChat) {
-        return NextResponse.json({ error: 'Chat not found' }, { status: 404 })
-      }
-    }
-
-    let agentContexts: Array<{ type: string; content: string }> = []
-    if (Array.isArray(contexts) && contexts.length > 0) {
-      try {
-        agentContexts = await processContextsServer(
-          contexts as any,
-          authenticatedUserId,
-          message,
-          workspaceId,
-          actualChatId
-        )
-      } catch (e) {
-        reqLogger.error('Failed to process contexts', e)
-      }
-    }
-
-    if (Array.isArray(resourceAttachments) && resourceAttachments.length > 0) {
-      const results = await Promise.allSettled(
-        resourceAttachments.map(async (r) => {
-          const ctx = await resolveActiveResourceContext(
-            r.type,
-            r.id,
-            workspaceId,
-            authenticatedUserId,
-            actualChatId
-          )
-          if (!ctx) return null
-          return {
-            ...ctx,
-            tag: r.active ? '@active_tab' : '@open_tab',
-          }
-        })
-      )
-      for (const result of results) {
-        if (result.status === 'fulfilled' && result.value) {
-          agentContexts.push(result.value)
-        } else if (result.status === 'rejected') {
-          reqLogger.error('Failed to resolve resource attachment', result.reason)
-        }
-      }
-    }
-
-    if (actualChatId) {
-      const userMsg = {
-        id: userMessageId,
-        role: 'user' as const,
-        content: message,
-        timestamp: new Date().toISOString(),
-        ...(fileAttachments &&
-          fileAttachments.length > 0 && {
-            fileAttachments: fileAttachments.map((f) => ({
-              id: f.id,
-              key: f.key,
-              filename: f.filename,
-              media_type: f.media_type,
-              size: f.size,
-            })),
-          }),
-        ...(contexts &&
-          contexts.length > 0 && {
-            contexts: contexts.map((c) => ({
-              kind: c.kind,
-              label: c.label,
-              ...(c.workflowId && { workflowId: c.workflowId }),
-              ...(c.knowledgeId && { knowledgeId: c.knowledgeId }),
-              ...(c.tableId && { tableId: c.tableId }),
-              ...(c.fileId && { fileId: c.fileId }),
-              ...(c.folderId && { folderId: c.folderId }),
-            })),
-          }),
-      }
-
-      const [updated] = await db
-        .update(copilotChats)
-        .set({
-          messages: sql`${copilotChats.messages} || ${JSON.stringify([userMsg])}::jsonb`,
-          conversationId: userMessageId,
-          updatedAt: new Date(),
-        })
-        .where(eq(copilotChats.id, actualChatId))
-        .returning({ messages: copilotChats.messages })
-
-      if (updated) {
-        const freshMessages: any[] = Array.isArray(updated.messages) ? updated.messages : []
-        conversationHistory = freshMessages.filter((m: any) => m.id !== userMessageId)
-        taskPubSub?.publishStatusChanged({ workspaceId, chatId: actualChatId, type: 'started' })
-      }
-    }
-
-    const [workspaceContext, userPermission] = await Promise.all([
-      generateWorkspaceContext(workspaceId, authenticatedUserId),
-      getUserEntityPermissions(authenticatedUserId, 'workspace', workspaceId).catch(() => null),
-    ])
-
-    const requestPayload = await buildCopilotRequestPayload(
-      {
-        message,
-        workspaceId,
-        userId: authenticatedUserId,
-        userMessageId,
-        mode: 'agent',
-        model: '',
-        contexts: agentContexts,
-        fileAttachments,
-        chatId: actualChatId,
-        userPermission: userPermission ?? undefined,
-        workspaceContext,
-        userTimezone,
-      },
-      { selectedModel: '' }
-    )
-
-    if (actualChatId) {
-      const acquired = await acquirePendingChatStream(actualChatId, userMessageId)
-      if (!acquired) {
-        return NextResponse.json(
-          {
-            error:
-              'A response is already in progress for this chat. Wait for it to finish or use Stop.',
-          },
-          { status: 409 }
-        )
-      }
-    }
-
-    const executionId = generateId()
-    const runId = generateId()
-    const stream = createSSEStream({
-      requestPayload,
-      userId: authenticatedUserId,
-      streamId: userMessageId,
-      executionId,
-      runId,
-      chatId: actualChatId,
-      currentChat,
-      isNewChat: conversationHistory.length === 0,
-      message,
-      titleModel: 'claude-opus-4-6',
-      requestId: tracker.requestId,
-      workspaceId,
-      pendingChatStreamAlreadyRegistered: Boolean(actualChatId),
-      orchestrateOptions: {
-        userId: authenticatedUserId,
-        workspaceId,
-        chatId: actualChatId,
-        executionId,
-        runId,
-        goRoute: '/api/mothership',
-        autoExecuteTools: true,
-        interactive: true,
-        onComplete: async (result: OrchestratorResult) => {
-          if (!actualChatId) return
-          if (!result.success) return
-
-          const assistantMessage: Record<string, unknown> = {
-            id: generateId(),
-            role: 'assistant' as const,
-            content: result.content,
-            timestamp: new Date().toISOString(),
-            ...(result.requestId ? { requestId: result.requestId } : {}),
-          }
-          if (result.toolCalls.length > 0) {
-            assistantMessage.toolCalls = result.toolCalls
-          }
-          if (result.contentBlocks.length > 0) {
-            assistantMessage.contentBlocks = result.contentBlocks.map((block) => {
-              const stored: Record<string, unknown> = { type: block.type }
-              if (block.content) stored.content = block.content
-              if (block.type === 'tool_call' && block.toolCall) {
-                const state =
-                  block.toolCall.result?.success !== undefined
-                    ? block.toolCall.result.success
-                      ? 'success'
-                      : 'error'
-                    : block.toolCall.status
-                const isSubagentTool = !!block.calledBy
-                const isNonTerminal =
-                  state === 'cancelled' || state === 'pending' || state === 'executing'
-                stored.toolCall = {
-                  id: block.toolCall.id,
-                  name: block.toolCall.name,
-                  state,
-                  ...(isSubagentTool && isNonTerminal ? {} : { result: block.toolCall.result }),
-                  ...(isSubagentTool && isNonTerminal
-                    ? {}
-                    : block.toolCall.params
-                      ? { params: block.toolCall.params }
-                      : {}),
-                  ...(block.calledBy ? { calledBy: block.calledBy } : {}),
-                }
-              }
-              return stored
-            })
-          }
-
-          try {
-            const [row] = await db
-              .select({ messages: copilotChats.messages })
-              .from(copilotChats)
-              .where(eq(copilotChats.id, actualChatId))
-              .limit(1)
-
-            const msgs: any[] = Array.isArray(row?.messages) ? row.messages : []
-            const userIdx = msgs.findIndex((m: any) => m.id === userMessageId)
-            const alreadyHasResponse =
-              userIdx >= 0 &&
-              userIdx + 1 < msgs.length &&
-              (msgs[userIdx + 1] as any)?.role === 'assistant'
-
-            if (!alreadyHasResponse) {
-              await db
-                .update(copilotChats)
-                .set({
-                  messages: sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`,
-                  conversationId: sql`CASE WHEN ${copilotChats.conversationId} = ${userMessageId} THEN NULL ELSE ${copilotChats.conversationId} END`,
-                  updatedAt: new Date(),
-                })
-                .where(eq(copilotChats.id, actualChatId))
-
-              taskPubSub?.publishStatusChanged({
-                workspaceId,
-                chatId: actualChatId,
-                type: 'completed',
-              })
-            }
-          } catch (error) {
-            reqLogger.error('Failed to persist chat messages', {
-              chatId: actualChatId,
-              error: error instanceof Error ? error.message : 'Unknown error',
-            })
-          }
-        },
-      },
-    })
-
-    return new Response(stream, { headers: SSE_RESPONSE_HEADERS })
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return NextResponse.json(
-        { error: 'Invalid request data', details: error.errors },
-        { status: 400 }
-      )
-    }
-
-    logger
-      .withMetadata({ requestId: tracker.requestId, messageId: userMessageIdForLogs })
-      .error('Error handling mothership chat', {
-        error: error instanceof Error ? error.message : 'Unknown error',
-      })
-
-    return NextResponse.json(
-      { error: error instanceof Error ? error.message : 'Internal server error' },
-      { status: 500 }
-    )
-  }
-}
+// Unified chat route surface.
+export { handleUnifiedChatPost as POST, maxDuration } from '@/lib/copilot/chat/post'
+export { GET } from '@/app/api/copilot/chat/queries'
diff --git a/apps/sim/app/api/mothership/chat/stop/route.ts b/apps/sim/app/api/mothership/chat/stop/route.ts
index 70dc1df7c87..dc1c7533ccd 100644
--- a/apps/sim/app/api/mothership/chat/stop/route.ts
+++ b/apps/sim/app/api/mothership/chat/stop/route.ts
@@ -1,114 +1,2 @@
-import { db } from '@sim/db'
-import { copilotChats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { and, eq, sql } from 'drizzle-orm'
-import { type NextRequest, NextResponse } from 'next/server'
-import { z } from 'zod'
-import { getSession } from '@/lib/auth'
-import { releasePendingChatStream } from '@/lib/copilot/chat-streaming'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { generateId } from '@/lib/core/utils/uuid'
-
-const logger = createLogger('MothershipChatStopAPI')
-
-const StoredToolCallSchema = z
-  .object({
-    id: z.string().optional(),
-    name: z.string().optional(),
-    state: z.string().optional(),
-    params: z.record(z.unknown()).optional(),
-    result: z
-      .object({
-        success: z.boolean(),
-        output: z.unknown().optional(),
-        error: z.string().optional(),
-      })
-      .optional(),
-    display: z
-      .object({
-        text: z.string().optional(),
-      })
-      .optional(),
-    calledBy: z.string().optional(),
-  })
-  .nullable()
-
-const ContentBlockSchema = z.object({
-  type: z.string(),
-  content: z.string().optional(),
-  toolCall: StoredToolCallSchema.optional(),
-})
-
-const StopSchema = z.object({
-  chatId: z.string(),
-  streamId: z.string(),
-  content: z.string(),
-  contentBlocks: z.array(ContentBlockSchema).optional(),
-})
-
-/**
- * POST /api/mothership/chat/stop
- * Persists partial assistant content when the user stops a stream mid-response.
- * Clears conversationId so the server-side onComplete won't duplicate the message.
- */
-export async function POST(req: NextRequest) {
-  try {
-    const session = await getSession()
-    if (!session?.user?.id) {
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-    }
-
-    const { chatId, streamId, content, contentBlocks } = StopSchema.parse(await req.json())
-
-    await releasePendingChatStream(chatId, streamId)
-
-    const setClause: Record<string, unknown> = {
-      conversationId: null,
-      updatedAt: new Date(),
-    }
-
-    const hasContent = content.trim().length > 0
-    const hasBlocks = Array.isArray(contentBlocks) && contentBlocks.length > 0
-
-    if (hasContent || hasBlocks) {
-      const assistantMessage: Record<string, unknown> = {
-        id: generateId(),
-        role: 'assistant' as const,
-        content,
-        timestamp: new Date().toISOString(),
-      }
-      if (hasBlocks) {
-        assistantMessage.contentBlocks = contentBlocks
-      }
-      setClause.messages = sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`
-    }
-
-    const [updated] = await db
-      .update(copilotChats)
-      .set(setClause)
-      .where(
-        and(
-          eq(copilotChats.id, chatId),
-          eq(copilotChats.userId, session.user.id),
-          eq(copilotChats.conversationId, streamId)
-        )
-      )
-      .returning({ workspaceId: copilotChats.workspaceId })
-
-    if (updated?.workspaceId) {
-      taskPubSub?.publishStatusChanged({
-        workspaceId: updated.workspaceId,
-        chatId,
-        type: 'completed',
-      })
-    }
-
-    return NextResponse.json({ success: true })
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return NextResponse.json({ error: 'Invalid request' }, { status: 400 })
-    }
-    logger.error('Error stopping chat stream:', error)
-    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
-  }
-}
+// Unified stop route surface.
+export { POST } from '@/app/api/copilot/chat/stop/route'
diff --git a/apps/sim/app/api/mothership/chat/stream/route.ts b/apps/sim/app/api/mothership/chat/stream/route.ts
new file mode 100644
index 00000000000..1d3bac30889
--- /dev/null
+++ b/apps/sim/app/api/mothership/chat/stream/route.ts
@@ -0,0 +1 @@
+export { GET, maxDuration } from '@/app/api/copilot/chat/stream/route'
diff --git a/apps/sim/app/api/mothership/chats/[chatId]/route.ts b/apps/sim/app/api/mothership/chats/[chatId]/route.ts
index 3101e681589..e5fc73f3017 100644
--- a/apps/sim/app/api/mothership/chats/[chatId]/route.ts
+++ b/apps/sim/app/api/mothership/chats/[chatId]/route.ts
@@ -4,15 +4,19 @@ import { createLogger } from '@sim/logger'
 import { and, eq, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { getAccessibleCopilotChat } from '@/lib/copilot/chat-lifecycle'
-import { getStreamMeta, readStreamEvents } from '@/lib/copilot/orchestrator/stream/buffer'
+import { getLatestRunForStream } from '@/lib/copilot/async-runs/repository'
+import { getAccessibleCopilotChat } from '@/lib/copilot/chat/lifecycle'
 import {
   authenticateCopilotRequestSessionOnly,
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
+} from '@/lib/copilot/request/http'
+import type { FilePreviewSession } from '@/lib/copilot/request/session'
+import { readEvents } from '@/lib/copilot/request/session/buffer'
+import { readFilePreviewSessions } from '@/lib/copilot/request/session/file-preview-session'
+import { type StreamBatchEvent, toStreamBatchEvent } from '@/lib/copilot/request/session/types'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { captureServerEvent } from '@/lib/posthog/server'
 
 const logger = createLogger('MothershipChatAPI')
@@ -47,29 +51,45 @@ export async function GET(
     }
 
     let streamSnapshot: {
-      events: Array<{ eventId: number; streamId: string; event: Record<string, unknown> }>
+      events: StreamBatchEvent[]
+      previewSessions: FilePreviewSession[]
       status: string
     } | null = null
 
     if (chat.conversationId) {
       try {
-        const [meta, events] = await Promise.all([
-          getStreamMeta(chat.conversationId),
-          readStreamEvents(chat.conversationId, 0),
+        const [events, previewSessions] = await Promise.all([
+          readEvents(chat.conversationId, '0'),
+          readFilePreviewSessions(chat.conversationId).catch((error) => {
+            logger.warn('Failed to read preview sessions for mothership chat', {
+              chatId,
+              conversationId: chat.conversationId,
+              error: error instanceof Error ? error.message : String(error),
+            })
+            return []
+          }),
         ])
-
-        streamSnapshot = {
-          events: events || [],
-          status: meta?.status || 'unknown',
-        }
-      } catch (error) {
-        logger
-          .withMetadata({ messageId: chat.conversationId || undefined })
-          .warn('Failed to read stream snapshot for mothership chat', {
+        const run = await getLatestRunForStream(chat.conversationId, userId).catch((error) => {
+          logger.warn('Failed to fetch latest run for mothership chat snapshot', {
             chatId,
             conversationId: chat.conversationId,
             error: error instanceof Error ? error.message : String(error),
           })
+          return null
+        })
+
+        streamSnapshot = {
+          events: events.map(toStreamBatchEvent),
+          previewSessions,
+          status:
+            typeof run?.status === 'string' ? run.status : events.length > 0 ? 'active' : 'unknown',
+        }
+      } catch (error) {
+        logger.warn('Failed to read stream snapshot for mothership chat', {
+          chatId,
+          conversationId: chat.conversationId,
+          error: error instanceof Error ? error.message : String(error),
+        })
       }
     }
 
diff --git a/apps/sim/app/api/mothership/chats/read/route.ts b/apps/sim/app/api/mothership/chats/read/route.ts
new file mode 100644
index 00000000000..344687ddfdc
--- /dev/null
+++ b/apps/sim/app/api/mothership/chats/read/route.ts
@@ -0,0 +1,43 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import {
+  authenticateCopilotRequestSessionOnly,
+  createBadRequestResponse,
+  createInternalServerErrorResponse,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request/http'
+
+const logger = createLogger('MarkTaskReadAPI')
+
+const MarkReadSchema = z.object({
+  chatId: z.string().min(1),
+})
+
+export async function POST(request: NextRequest) {
+  try {
+    const { userId, isAuthenticated } = await authenticateCopilotRequestSessionOnly()
+    if (!isAuthenticated || !userId) {
+      return createUnauthorizedResponse()
+    }
+
+    const body = await request.json()
+    const { chatId } = MarkReadSchema.parse(body)
+
+    await db
+      .update(copilotChats)
+      .set({ lastSeenAt: sql`GREATEST(${copilotChats.updatedAt}, NOW())` })
+      .where(and(eq(copilotChats.id, chatId), eq(copilotChats.userId, userId)))
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return createBadRequestResponse('chatId is required')
+    }
+    logger.error('Error marking task as read:', error)
+    return createInternalServerErrorResponse('Failed to mark task as read')
+  }
+}
diff --git a/apps/sim/app/api/mothership/chats/route.ts b/apps/sim/app/api/mothership/chats/route.ts
index bc694d1d9fe..99bd6fd7390 100644
--- a/apps/sim/app/api/mothership/chats/route.ts
+++ b/apps/sim/app/api/mothership/chats/route.ts
@@ -9,8 +9,8 @@ import {
   createBadRequestResponse,
   createInternalServerErrorResponse,
   createUnauthorizedResponse,
-} from '@/lib/copilot/request-helpers'
-import { taskPubSub } from '@/lib/copilot/task-events'
+} from '@/lib/copilot/request/http'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { captureServerEvent } from '@/lib/posthog/server'
 import { assertActiveWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -39,7 +39,7 @@ export async function GET(request: NextRequest) {
         id: copilotChats.id,
         title: copilotChats.title,
         updatedAt: copilotChats.updatedAt,
-        conversationId: copilotChats.conversationId,
+        activeStreamId: copilotChats.conversationId,
         lastSeenAt: copilotChats.lastSeenAt,
       })
       .from(copilotChats)
diff --git a/apps/sim/app/api/mothership/events/route.ts b/apps/sim/app/api/mothership/events/route.ts
index 38abba7b33f..4f1646f6e34 100644
--- a/apps/sim/app/api/mothership/events/route.ts
+++ b/apps/sim/app/api/mothership/events/route.ts
@@ -7,7 +7,7 @@
  * Auth is handled via session cookies (EventSource sends cookies automatically).
  */
 
-import { taskPubSub } from '@/lib/copilot/task-events'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { createWorkspaceSSE } from '@/lib/events/sse-endpoint'
 
 export const dynamic = 'force-dynamic'
diff --git a/apps/sim/app/api/mothership/execute/route.ts b/apps/sim/app/api/mothership/execute/route.ts
index 619e0135726..e0e3ac4c83c 100644
--- a/apps/sim/app/api/mothership/execute/route.ts
+++ b/apps/sim/app/api/mothership/execute/route.ts
@@ -2,10 +2,10 @@ import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { checkInternalAuth } from '@/lib/auth/hybrid'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { buildIntegrationToolSchemas } from '@/lib/copilot/chat-payload'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import { generateWorkspaceContext } from '@/lib/copilot/workspace-context'
+import { buildIntegrationToolSchemas } from '@/lib/copilot/chat/payload'
+import { generateWorkspaceContext } from '@/lib/copilot/chat/workspace-context'
+import { runHeadlessCopilotLifecycle } from '@/lib/copilot/request/lifecycle/headless'
+import { requestExplicitStreamAbort } from '@/lib/copilot/request/session/explicit-abort'
 import { generateId } from '@/lib/core/utils/uuid'
 import {
   assertActiveWorkspaceAccess,
@@ -27,8 +27,16 @@ const ExecuteRequestSchema = z.object({
   workspaceId: z.string().min(1, 'workspaceId is required'),
   userId: z.string().min(1, 'userId is required'),
   chatId: z.string().optional(),
+  messageId: z.string().optional(),
+  requestId: z.string().optional(),
+  workflowId: z.string().optional(),
+  executionId: z.string().optional(),
 })
 
+function isAbortError(error: unknown): boolean {
+  return error instanceof Error && error.name === 'AbortError'
+}
+
 /**
  * POST /api/mothership/execute
  *
@@ -38,6 +46,7 @@ const ExecuteRequestSchema = z.object({
  */
 export async function POST(req: NextRequest) {
   let messageId: string | undefined
+  let requestId: string | undefined
 
   try {
     const auth = await checkInternalAuth(req, { requireWorkflowId: false })
@@ -46,14 +55,29 @@ export async function POST(req: NextRequest) {
     }
 
     const body = await req.json()
-    const { messages, responseFormat, workspaceId, userId, chatId } =
-      ExecuteRequestSchema.parse(body)
+    const {
+      messages,
+      responseFormat,
+      workspaceId,
+      userId,
+      chatId,
+      messageId: providedMessageId,
+      requestId: providedRequestId,
+      workflowId,
+      executionId,
+    } = ExecuteRequestSchema.parse(body)
 
     await assertActiveWorkspaceAccess(workspaceId, userId)
 
     const effectiveChatId = chatId || generateId()
-    messageId = generateId()
-    const reqLogger = logger.withMetadata({ messageId })
+    messageId = providedMessageId || generateId()
+    requestId = providedRequestId || generateId()
+    const reqLogger = logger.withMetadata({
+      messageId,
+      requestId,
+      workflowId,
+      executionId,
+    })
     const [workspaceContext, integrationTools, userPermission] = await Promise.all([
       generateWorkspaceContext(workspaceId, userId),
       buildIntegrationToolSchemas(userId, messageId),
@@ -73,61 +97,96 @@ export async function POST(req: NextRequest) {
       ...(userPermission ? { userPermission } : {}),
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-
-    await createRunSegment({
-      id: runId,
-      executionId,
-      chatId: effectiveChatId,
-      userId,
-      workspaceId,
-      streamId: messageId,
-    }).catch(() => {})
-
-    const result = await orchestrateCopilotStream(requestPayload, {
-      userId,
-      workspaceId,
-      chatId: effectiveChatId,
-      executionId,
-      runId,
-      goRoute: '/api/mothership/execute',
-      autoExecuteTools: true,
-      interactive: false,
-    })
-
-    if (!result.success) {
-      reqLogger.error('Mothership execute failed', {
-        error: result.error,
-        errors: result.errors,
+    let allowExplicitAbort = true
+    let explicitAbortRequest: Promise<void> | undefined
+    const onAbort = () => {
+      if (!allowExplicitAbort || explicitAbortRequest || !messageId) {
+        return
+      }
+
+      explicitAbortRequest = requestExplicitStreamAbort({
+        streamId: messageId,
+        userId,
+        chatId: effectiveChatId,
+      }).catch((error) => {
+        reqLogger.warn('Failed to send explicit abort for mothership execution', {
+          error: error instanceof Error ? error.message : String(error),
+        })
       })
-      return NextResponse.json(
-        {
-          error: result.error || 'Mothership execution failed',
-          content: result.content || '',
-        },
-        { status: 500 }
-      )
     }
 
-    const clientToolNames = new Set(integrationTools.map((t) => t.name))
-    const clientToolCalls = (result.toolCalls || []).filter(
-      (tc: { name: string }) => clientToolNames.has(tc.name) || tc.name.startsWith('mcp-')
-    )
+    if (req.signal.aborted) {
+      onAbort()
+    } else {
+      req.signal.addEventListener('abort', onAbort, { once: true })
+    }
+
+    try {
+      const result = await runHeadlessCopilotLifecycle(requestPayload, {
+        userId,
+        workspaceId,
+        chatId: effectiveChatId,
+        workflowId,
+        executionId,
+        simRequestId: requestId,
+        goRoute: '/api/mothership/execute',
+        autoExecuteTools: true,
+        interactive: false,
+        abortSignal: req.signal,
+      })
 
-    return NextResponse.json({
-      content: result.content,
-      model: 'mothership',
-      tokens: result.usage
-        ? {
-            prompt: result.usage.prompt,
-            completion: result.usage.completion,
-            total: (result.usage.prompt || 0) + (result.usage.completion || 0),
+      allowExplicitAbort = false
+
+      if (req.signal.aborted) {
+        reqLogger.info('Mothership execute aborted after lifecycle completion')
+        return NextResponse.json({ error: 'Mothership execution aborted' }, { status: 499 })
+      }
+
+      if (!result.success) {
+        logger.error(
+          messageId
+            ? `Mothership execute failed [messageId:${messageId}]`
+            : 'Mothership execute failed',
+          {
+            requestId,
+            workflowId,
+            executionId,
+            error: result.error,
+            errors: result.errors,
           }
-        : {},
-      cost: result.cost || undefined,
-      toolCalls: clientToolCalls,
-    })
+        )
+        return NextResponse.json(
+          {
+            error: result.error || 'Mothership execution failed',
+            content: result.content || '',
+          },
+          { status: 500 }
+        )
+      }
+
+      const clientToolNames = new Set(integrationTools.map((t) => t.name))
+      const clientToolCalls = (result.toolCalls || []).filter(
+        (tc: { name: string }) => clientToolNames.has(tc.name) || tc.name.startsWith('mcp-')
+      )
+
+      return NextResponse.json({
+        content: result.content,
+        model: 'mothership',
+        tokens: result.usage
+          ? {
+              prompt: result.usage.prompt,
+              completion: result.usage.completion,
+              total: (result.usage.prompt || 0) + (result.usage.completion || 0),
+            }
+          : {},
+        cost: result.cost || undefined,
+        toolCalls: clientToolCalls,
+      })
+    } finally {
+      allowExplicitAbort = false
+      req.signal.removeEventListener('abort', onAbort)
+      await explicitAbortRequest
+    }
   } catch (error) {
     if (error instanceof z.ZodError) {
       return NextResponse.json(
@@ -136,9 +195,26 @@ export async function POST(req: NextRequest) {
       )
     }
 
-    logger.withMetadata({ messageId }).error('Mothership execute error', {
-      error: error instanceof Error ? error.message : 'Unknown error',
-    })
+    if (req.signal.aborted || isAbortError(error)) {
+      logger.info(
+        messageId
+          ? `Mothership execute aborted [messageId:${messageId}]`
+          : 'Mothership execute aborted',
+        {
+          requestId,
+        }
+      )
+
+      return NextResponse.json({ error: 'Mothership execution aborted' }, { status: 499 })
+    }
+
+    logger.error(
+      messageId ? `Mothership execute error [messageId:${messageId}]` : 'Mothership execute error',
+      {
+        requestId,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      }
+    )
 
     return NextResponse.json(
       { error: error instanceof Error ? error.message : 'Internal server error' },
diff --git a/apps/sim/app/api/resume/[workflowId]/[executionId]/[contextId]/route.ts b/apps/sim/app/api/resume/[workflowId]/[executionId]/[contextId]/route.ts
index f6a33f823e7..80832187d86 100644
--- a/apps/sim/app/api/resume/[workflowId]/[executionId]/[contextId]/route.ts
+++ b/apps/sim/app/api/resume/[workflowId]/[executionId]/[contextId]/route.ts
@@ -1,13 +1,11 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { AuthType } from '@/lib/auth/hybrid'
-import { getJobQueue, shouldUseBullMQ } from '@/lib/core/async-jobs'
-import { createBullMQJobData } from '@/lib/core/bullmq'
+import { getJobQueue } from '@/lib/core/async-jobs'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { SSE_HEADERS } from '@/lib/core/utils/sse'
 import { getBaseUrl } from '@/lib/core/utils/urls'
 import { generateId } from '@/lib/core/utils/uuid'
-import { enqueueWorkspaceDispatch } from '@/lib/core/workspace-dispatch'
 import { setExecutionMeta } from '@/lib/execution/event-buffer'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
 import { PauseResumeManager } from '@/lib/workflows/executor/human-in-the-loop-manager'
@@ -227,26 +225,10 @@ export async function POST(
 
       let jobId: string
       try {
-        const useBullMQ = shouldUseBullMQ()
-        if (useBullMQ) {
-          jobId = await enqueueWorkspaceDispatch({
-            id: enqueueResult.resumeExecutionId,
-            workspaceId: workflow.workspaceId,
-            lane: 'runtime',
-            queueName: 'resume-execution',
-            bullmqJobName: 'resume-execution',
-            bullmqPayload: createBullMQJobData(resumePayload, {
-              workflowId,
-              userId,
-            }),
-            metadata: { workflowId, userId },
-          })
-        } else {
-          const jobQueue = await getJobQueue()
-          jobId = await jobQueue.enqueue('resume-execution', resumePayload, {
-            metadata: { workflowId, workspaceId: workflow.workspaceId, userId },
-          })
-        }
+        const jobQueue = await getJobQueue()
+        jobId = await jobQueue.enqueue('resume-execution', resumePayload, {
+          metadata: { workflowId, workspaceId: workflow.workspaceId, userId },
+        })
         logger.info('Enqueued async resume execution', {
           jobId,
           resumeExecutionId: enqueueResult.resumeExecutionId,
diff --git a/apps/sim/app/api/schedules/execute/route.test.ts b/apps/sim/app/api/schedules/execute/route.test.ts
index 12dd33097e1..aa1fba6d7b6 100644
--- a/apps/sim/app/api/schedules/execute/route.test.ts
+++ b/apps/sim/app/api/schedules/execute/route.test.ts
@@ -14,7 +14,6 @@ const {
   mockDbReturning,
   mockDbUpdate,
   mockEnqueue,
-  mockEnqueueWorkspaceDispatch,
   mockStartJob,
   mockCompleteJob,
   mockMarkJobFailed,
@@ -24,7 +23,6 @@ const {
   const mockDbSet = vi.fn().mockReturnValue({ where: mockDbWhere })
   const mockDbUpdate = vi.fn().mockReturnValue({ set: mockDbSet })
   const mockEnqueue = vi.fn().mockResolvedValue('job-id-1')
-  const mockEnqueueWorkspaceDispatch = vi.fn().mockResolvedValue('job-id-1')
   const mockStartJob = vi.fn().mockResolvedValue(undefined)
   const mockCompleteJob = vi.fn().mockResolvedValue(undefined)
   const mockMarkJobFailed = vi.fn().mockResolvedValue(undefined)
@@ -42,7 +40,6 @@ const {
     mockDbReturning,
     mockDbUpdate,
     mockEnqueue,
-    mockEnqueueWorkspaceDispatch,
     mockStartJob,
     mockCompleteJob,
     mockMarkJobFailed,
@@ -75,15 +72,6 @@ vi.mock('@/lib/core/async-jobs', () => ({
   shouldExecuteInline: vi.fn().mockReturnValue(false),
 }))
 
-vi.mock('@/lib/core/bullmq', () => ({
-  isBullMQEnabled: vi.fn().mockReturnValue(true),
-  createBullMQJobData: vi.fn((payload: unknown) => ({ payload })),
-}))
-
-vi.mock('@/lib/core/workspace-dispatch', () => ({
-  enqueueWorkspaceDispatch: mockEnqueueWorkspaceDispatch,
-}))
-
 vi.mock('@/lib/workflows/utils', () => ({
   getWorkflowById: vi.fn().mockResolvedValue({
     id: 'workflow-1',
@@ -175,8 +163,6 @@ const SINGLE_JOB = [
     cronExpression: '0 * * * *',
     failedCount: 0,
     lastQueuedAt: undefined,
-    sourceUserId: 'user-1',
-    sourceWorkspaceId: 'workspace-1',
     sourceType: 'job',
   },
 ]
@@ -250,56 +236,48 @@ describe('Scheduled Workflow Execution API Route', () => {
     expect(data).toHaveProperty('executedCount', 2)
   })
 
-  it('should queue mothership jobs to BullMQ when available', async () => {
+  it('should execute mothership jobs inline', async () => {
     mockDbReturning.mockReturnValueOnce([]).mockReturnValueOnce(SINGLE_JOB)
 
     const response = await GET(createMockRequest())
 
     expect(response.status).toBe(200)
-    expect(mockEnqueueWorkspaceDispatch).toHaveBeenCalledWith(
+    expect(mockExecuteJobInline).toHaveBeenCalledWith(
       expect.objectContaining({
-        workspaceId: 'workspace-1',
-        lane: 'runtime',
-        queueName: 'mothership-job-execution',
-        bullmqJobName: 'mothership-job-execution',
-        bullmqPayload: {
-          payload: {
-            scheduleId: 'job-1',
-            cronExpression: '0 * * * *',
-            failedCount: 0,
-            now: expect.any(String),
-          },
-        },
+        scheduleId: 'job-1',
+        cronExpression: '0 * * * *',
+        failedCount: 0,
+        now: expect.any(String),
       })
     )
-    expect(mockExecuteJobInline).not.toHaveBeenCalled()
   })
 
-  it('should enqueue preassigned correlation metadata for schedules', async () => {
-    mockDbReturning.mockReturnValue(SINGLE_SCHEDULE)
+  it('should enqueue schedule with correlation metadata via job queue', async () => {
+    mockDbReturning.mockReturnValueOnce(SINGLE_SCHEDULE).mockReturnValueOnce([])
 
     const response = await GET(createMockRequest())
 
     expect(response.status).toBe(200)
-    expect(mockEnqueueWorkspaceDispatch).toHaveBeenCalledWith(
+    expect(mockEnqueue).toHaveBeenCalledWith(
+      'schedule-execution',
+      expect.objectContaining({
+        scheduleId: 'schedule-1',
+        workflowId: 'workflow-1',
+        executionId: 'schedule-execution-1',
+        requestId: 'test-request-id',
+      }),
       expect.objectContaining({
-        id: 'schedule-execution-1',
-        workspaceId: 'workspace-1',
-        lane: 'runtime',
-        queueName: 'schedule-execution',
-        bullmqJobName: 'schedule-execution',
-        metadata: {
+        metadata: expect.objectContaining({
           workflowId: 'workflow-1',
-          correlation: {
+          workspaceId: 'workspace-1',
+          correlation: expect.objectContaining({
             executionId: 'schedule-execution-1',
             requestId: 'test-request-id',
             source: 'schedule',
             workflowId: 'workflow-1',
             scheduleId: 'schedule-1',
-            triggerType: 'schedule',
-            scheduledFor: '2025-01-01T00:00:00.000Z',
-          },
-        },
+          }),
+        }),
       })
     )
   })
diff --git a/apps/sim/app/api/schedules/execute/route.ts b/apps/sim/app/api/schedules/execute/route.ts
index 176103d682f..4748d1f4379 100644
--- a/apps/sim/app/api/schedules/execute/route.ts
+++ b/apps/sim/app/api/schedules/execute/route.ts
@@ -4,11 +4,8 @@ import { and, eq, isNull, lt, lte, ne, not, or, sql } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { verifyCronAuth } from '@/lib/auth/internal'
 import { getJobQueue, shouldExecuteInline } from '@/lib/core/async-jobs'
-import { createBullMQJobData, isBullMQEnabled } from '@/lib/core/bullmq'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { generateId } from '@/lib/core/utils/uuid'
-import { enqueueWorkspaceDispatch } from '@/lib/core/workspace-dispatch'
-import { getWorkflowById } from '@/lib/workflows/utils'
 import {
   executeJobInline,
   executeScheduleJob,
@@ -76,8 +73,6 @@ export async function GET(request: NextRequest) {
         cronExpression: workflowSchedule.cronExpression,
         failedCount: workflowSchedule.failedCount,
         lastQueuedAt: workflowSchedule.lastQueuedAt,
-        sourceWorkspaceId: workflowSchedule.sourceWorkspaceId,
-        sourceUserId: workflowSchedule.sourceUserId,
         sourceType: workflowSchedule.sourceType,
       })
 
@@ -88,6 +83,9 @@ export async function GET(request: NextRequest) {
 
     const jobQueue = await getJobQueue()
 
+    const workflowUtils =
+      dueSchedules.length > 0 ? await import('@/lib/workflows/utils') : undefined
+
     const schedulePromises = dueSchedules.map(async (schedule) => {
       const queueTime = schedule.lastQueuedAt ?? queuedAt
       const executionId = generateId()
@@ -117,42 +115,17 @@ export async function GET(request: NextRequest) {
 
       try {
         const resolvedWorkflow = schedule.workflowId
-          ? await getWorkflowById(schedule.workflowId)
+          ? await workflowUtils?.getWorkflowById(schedule.workflowId)
           : null
         const resolvedWorkspaceId = resolvedWorkflow?.workspaceId
 
-        let jobId: string
-        if (isBullMQEnabled()) {
-          if (!resolvedWorkspaceId) {
-            throw new Error(
-              `Missing workspace for scheduled workflow ${schedule.workflowId}; refusing to bypass workspace admission`
-            )
-          }
-
-          jobId = await enqueueWorkspaceDispatch({
-            id: executionId,
-            workspaceId: resolvedWorkspaceId,
-            lane: 'runtime',
-            queueName: 'schedule-execution',
-            bullmqJobName: 'schedule-execution',
-            bullmqPayload: createBullMQJobData(payload, {
-              workflowId: schedule.workflowId ?? undefined,
-              correlation,
-            }),
-            metadata: {
-              workflowId: schedule.workflowId ?? undefined,
-              correlation,
-            },
-          })
-        } else {
-          jobId = await jobQueue.enqueue('schedule-execution', payload, {
-            metadata: {
-              workflowId: schedule.workflowId ?? undefined,
-              workspaceId: resolvedWorkspaceId ?? undefined,
-              correlation,
-            },
-          })
-        }
+        const jobId = await jobQueue.enqueue('schedule-execution', payload, {
+          metadata: {
+            workflowId: schedule.workflowId ?? undefined,
+            workspaceId: resolvedWorkspaceId ?? undefined,
+            correlation,
+          },
+        })
         logger.info(
           `[${requestId}] Queued schedule execution task ${jobId} for workflow ${schedule.workflowId}`
         )
@@ -204,7 +177,7 @@ export async function GET(request: NextRequest) {
       }
     })
 
-    // Mothership jobs use BullMQ when available, otherwise direct inline execution.
+    // Mothership jobs are executed inline directly.
     const jobPromises = dueJobs.map(async (job) => {
       const queueTime = job.lastQueuedAt ?? queuedAt
       const payload = {
@@ -215,24 +188,7 @@ export async function GET(request: NextRequest) {
       }
 
       try {
-        if (isBullMQEnabled()) {
-          if (!job.sourceWorkspaceId || !job.sourceUserId) {
-            throw new Error(`Mothership job ${job.id} is missing workspace/user ownership`)
-          }
-
-          await enqueueWorkspaceDispatch({
-            workspaceId: job.sourceWorkspaceId!,
-            lane: 'runtime',
-            queueName: 'mothership-job-execution',
-            bullmqJobName: 'mothership-job-execution',
-            bullmqPayload: createBullMQJobData(payload),
-            metadata: {
-              userId: job.sourceUserId,
-            },
-          })
-        } else {
-          await executeJobInline(payload)
-        }
+        await executeJobInline(payload)
       } catch (error) {
         logger.error(`[${requestId}] Job execution failed for ${job.id}`, {
           error: error instanceof Error ? error.message : String(error),
diff --git a/apps/sim/app/api/templates/approved/sanitized/route.ts b/apps/sim/app/api/templates/approved/sanitized/route.ts
index 2b6fad9652a..dd72ef80464 100644
--- a/apps/sim/app/api/templates/approved/sanitized/route.ts
+++ b/apps/sim/app/api/templates/approved/sanitized/route.ts
@@ -3,7 +3,7 @@ import { templates } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
-import { checkInternalApiKey } from '@/lib/copilot/utils'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 
diff --git a/apps/sim/app/api/v1/copilot/chat/route.ts b/apps/sim/app/api/v1/copilot/chat/route.ts
index 52be435d681..dc8370ff83d 100644
--- a/apps/sim/app/api/v1/copilot/chat/route.ts
+++ b/apps/sim/app/api/v1/copilot/chat/route.ts
@@ -1,9 +1,8 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { COPILOT_REQUEST_MODES } from '@/lib/copilot/models'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
+import { COPILOT_REQUEST_MODES } from '@/lib/copilot/constants'
+import { runHeadlessCopilotLifecycle } from '@/lib/copilot/request/lifecycle/headless'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getWorkflowById, resolveWorkflowIdForUser } from '@/lib/workflows/utils'
 import { authenticateV1Request } from '@/app/api/v1/auth'
@@ -84,15 +83,19 @@ export async function POST(req: NextRequest) {
     const chatId = parsed.chatId || generateId()
 
     messageId = generateId()
-    const reqLogger = logger.withMetadata({ messageId })
-    reqLogger.info('Received headless copilot chat start request', {
-      workflowId: resolved.workflowId,
-      workflowName: parsed.workflowName,
-      chatId,
-      mode: transportMode,
-      autoExecuteTools: parsed.autoExecuteTools,
-      timeout: parsed.timeout,
-    })
+    logger.info(
+      messageId
+        ? `Received headless copilot chat start request [messageId:${messageId}]`
+        : 'Received headless copilot chat start request',
+      {
+        workflowId: resolved.workflowId,
+        workflowName: parsed.workflowName,
+        chatId,
+        mode: transportMode,
+        autoExecuteTools: parsed.autoExecuteTools,
+        timeout: parsed.timeout,
+      }
+    )
     const requestPayload = {
       message: parsed.message,
       workflowId: resolved.workflowId,
@@ -103,24 +106,10 @@ export async function POST(req: NextRequest) {
       chatId,
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-
-    await createRunSegment({
-      id: runId,
-      executionId,
-      chatId,
-      userId: auth.userId,
-      workflowId: resolved.workflowId,
-      streamId: messageId,
-    }).catch(() => {})
-
-    const result = await orchestrateCopilotStream(requestPayload, {
+    const result = await runHeadlessCopilotLifecycle(requestPayload, {
       userId: auth.userId,
       workflowId: resolved.workflowId,
       chatId,
-      executionId,
-      runId,
       goRoute: '/api/mcp',
       autoExecuteTools: parsed.autoExecuteTools,
       timeout: parsed.timeout,
@@ -142,9 +131,14 @@ export async function POST(req: NextRequest) {
       )
     }
 
-    logger.withMetadata({ messageId }).error('Headless copilot request failed', {
-      error: error instanceof Error ? error.message : String(error),
-    })
+    logger.error(
+      messageId
+        ? `Headless copilot request failed [messageId:${messageId}]`
+        : 'Headless copilot request failed',
+      {
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
     return NextResponse.json({ success: false, error: 'Internal server error' }, { status: 500 })
   }
 }
diff --git a/apps/sim/app/api/webhooks/trigger/[path]/route.ts b/apps/sim/app/api/webhooks/trigger/[path]/route.ts
index 46ec98d4735..abb37e8960e 100644
--- a/apps/sim/app/api/webhooks/trigger/[path]/route.ts
+++ b/apps/sim/app/api/webhooks/trigger/[path]/route.ts
@@ -2,7 +2,6 @@ import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { admissionRejectedResponse, tryAdmit } from '@/lib/core/admission/gate'
 import { generateRequestId } from '@/lib/core/utils/request'
-import { DispatchQueueFullError } from '@/lib/core/workspace-dispatch'
 import {
   checkWebhookPreprocessing,
   findAllWebhooksForPath,
@@ -156,29 +155,14 @@ async function handleWebhookPost(
     if (shouldSkipWebhookEvent(foundWebhook, body, requestId)) {
       continue
     }
-
-    try {
-      const response = await queueWebhookExecution(foundWebhook, foundWorkflow, body, request, {
-        requestId,
-        path,
-        actorUserId: preprocessResult.actorUserId,
-        executionId: preprocessResult.executionId,
-        correlation: preprocessResult.correlation,
-      })
-      responses.push(response)
-    } catch (error) {
-      if (error instanceof DispatchQueueFullError) {
-        return NextResponse.json(
-          {
-            error: 'Service temporarily at capacity',
-            message: error.message,
-            retryAfterSeconds: 10,
-          },
-          { status: 503, headers: { 'Retry-After': '10' } }
-        )
-      }
-      throw error
-    }
+    const response = await queueWebhookExecution(foundWebhook, foundWorkflow, body, request, {
+      requestId,
+      path,
+      actorUserId: preprocessResult.actorUserId,
+      executionId: preprocessResult.executionId,
+      correlation: preprocessResult.correlation,
+    })
+    responses.push(response)
   }
 
   if (responses.length === 0) {
diff --git a/apps/sim/app/api/workflows/[id]/chat/status/route.test.ts b/apps/sim/app/api/workflows/[id]/chat/status/route.test.ts
index 48a36ca069c..19917b7d8cb 100644
--- a/apps/sim/app/api/workflows/[id]/chat/status/route.test.ts
+++ b/apps/sim/app/api/workflows/[id]/chat/status/route.test.ts
@@ -122,7 +122,7 @@ describe('Workflow Chat Status Route', () => {
         customizations: { theme: 'dark' },
         authType: 'public',
         allowedEmails: [],
-        outputConfigs: {},
+        outputConfigs: [{ blockId: 'agent-1', path: 'content' }],
         password: 'secret',
         isActive: true,
       },
@@ -136,5 +136,6 @@ describe('Workflow Chat Status Route', () => {
     expect(data.isDeployed).toBe(true)
     expect(data.deployment.id).toBe('chat-1')
     expect(data.deployment.hasPassword).toBe(true)
+    expect(data.deployment.outputConfigs).toEqual([{ blockId: 'agent-1', path: 'content' }])
   })
 })
diff --git a/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts b/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts
index 77feaf9843a..81ef1a01ccf 100644
--- a/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts
+++ b/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts
@@ -10,13 +10,11 @@ const {
   mockAuthorizeWorkflowByWorkspacePermission,
   mockPreprocessExecution,
   mockEnqueue,
-  mockEnqueueWorkspaceDispatch,
 } = vi.hoisted(() => ({
   mockCheckHybridAuth: vi.fn(),
   mockAuthorizeWorkflowByWorkspacePermission: vi.fn(),
   mockPreprocessExecution: vi.fn(),
   mockEnqueue: vi.fn().mockResolvedValue('job-123'),
-  mockEnqueueWorkspaceDispatch: vi.fn().mockResolvedValue('job-123'),
 }))
 
 vi.mock('@/lib/auth/hybrid', () => ({
@@ -47,16 +45,6 @@ vi.mock('@/lib/core/async-jobs', () => ({
     markJobFailed: vi.fn(),
   }),
   shouldExecuteInline: vi.fn().mockReturnValue(false),
-  shouldUseBullMQ: vi.fn().mockReturnValue(true),
-}))
-
-vi.mock('@/lib/core/bullmq', () => ({
-  createBullMQJobData: vi.fn((payload: unknown, metadata?: unknown) => ({ payload, metadata })),
-}))
-
-vi.mock('@/lib/core/workspace-dispatch', () => ({
-  enqueueWorkspaceDispatch: mockEnqueueWorkspaceDispatch,
-  waitForDispatchJob: vi.fn(),
 }))
 
 vi.mock('@/lib/core/utils/request', () => ({
@@ -150,24 +138,28 @@ describe('workflow execute async route', () => {
     expect(response.status).toBe(202)
     expect(body.executionId).toBe('execution-123')
     expect(body.jobId).toBe('job-123')
-    expect(mockEnqueueWorkspaceDispatch).toHaveBeenCalledWith(
+    expect(mockEnqueue).toHaveBeenCalledWith(
+      'workflow-execution',
       expect.objectContaining({
-        id: 'execution-123',
+        workflowId: 'workflow-1',
+        userId: 'actor-1',
         workspaceId: 'workspace-1',
-        lane: 'runtime',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'workflow-execution',
-        metadata: {
+        executionId: 'execution-123',
+        executionMode: 'async',
+      }),
+      expect.objectContaining({
+        metadata: expect.objectContaining({
           workflowId: 'workflow-1',
           userId: 'actor-1',
-          correlation: {
+          workspaceId: 'workspace-1',
+          correlation: expect.objectContaining({
             executionId: 'execution-123',
             requestId: 'req-12345678',
             source: 'workflow',
             workflowId: 'workflow-1',
             triggerType: 'manual',
-          },
-        },
+          }),
+        }),
       })
     )
   })
diff --git a/apps/sim/app/api/workflows/[id]/execute/route.ts b/apps/sim/app/api/workflows/[id]/execute/route.ts
index c715ca2a8bc..2f9a72cf1eb 100644
--- a/apps/sim/app/api/workflows/[id]/execute/route.ts
+++ b/apps/sim/app/api/workflows/[id]/execute/route.ts
@@ -3,8 +3,7 @@ import { type NextRequest, NextResponse } from 'next/server'
 import { z } from 'zod'
 import { AuthType, checkHybridAuth, hasExternalApiCredentials } from '@/lib/auth/hybrid'
 import { admissionRejectedResponse, tryAdmit } from '@/lib/core/admission/gate'
-import { getJobQueue, shouldExecuteInline, shouldUseBullMQ } from '@/lib/core/async-jobs'
-import { createBullMQJobData } from '@/lib/core/bullmq'
+import { getJobQueue, shouldExecuteInline } from '@/lib/core/async-jobs'
 import {
   createTimeoutAbortController,
   getTimeoutErrorMessage,
@@ -14,13 +13,6 @@ import { generateRequestId } from '@/lib/core/utils/request'
 import { SSE_HEADERS } from '@/lib/core/utils/sse'
 import { getBaseUrl } from '@/lib/core/utils/urls'
 import { generateId, isValidUuid } from '@/lib/core/utils/uuid'
-import {
-  DispatchQueueFullError,
-  enqueueWorkspaceDispatch,
-  type WorkspaceDispatchLane,
-  waitForDispatchJob,
-} from '@/lib/core/workspace-dispatch'
-import { createBufferedExecutionStream } from '@/lib/execution/buffered-stream'
 import {
   buildNextCallChain,
   parseCallChain,
@@ -43,11 +35,6 @@ import { executeWorkflow } from '@/lib/workflows/executor/execute-workflow'
 import { executeWorkflowCore } from '@/lib/workflows/executor/execution-core'
 import { type ExecutionEvent, encodeSSEEvent } from '@/lib/workflows/executor/execution-events'
 import { handlePostExecutionPauseState } from '@/lib/workflows/executor/pause-persistence'
-import {
-  DIRECT_WORKFLOW_JOB_NAME,
-  type QueuedWorkflowExecutionPayload,
-  type QueuedWorkflowExecutionResult,
-} from '@/lib/workflows/executor/queued-workflow-execution'
 import {
   loadDeployedWorkflowState,
   loadWorkflowFromNormalizedTables,
@@ -91,6 +78,7 @@ const ExecuteWorkflowSchema = z.object({
       parallels: z.record(z.any()).optional(),
     })
     .optional(),
+  triggerBlockId: z.string().optional(),
   stopAfterBlockId: z.string().optional(),
   runFromBlock: z
     .object({
@@ -119,8 +107,6 @@ const ExecuteWorkflowSchema = z.object({
 export const runtime = 'nodejs'
 export const dynamic = 'force-dynamic'
 
-const INLINE_TRIGGER_TYPES = new Set<CoreTriggerType>(['manual', 'workflow'])
-
 function resolveOutputIds(
   selectedOutputs: string[] | undefined,
   blocks: Record<string, any>
@@ -218,39 +204,19 @@ async function handleAsyncExecution(params: AsyncExecutionParams): Promise<NextR
   }
 
   try {
-    const useBullMQ = shouldUseBullMQ()
-    const jobQueue = useBullMQ ? null : await getJobQueue()
-    const jobId = useBullMQ
-      ? await enqueueWorkspaceDispatch({
-          id: executionId,
-          workspaceId,
-          lane: 'runtime',
-          queueName: 'workflow-execution',
-          bullmqJobName: 'workflow-execution',
-          bullmqPayload: createBullMQJobData(payload, {
-            workflowId,
-            userId,
-            correlation,
-          }),
-          metadata: {
-            workflowId,
-            userId,
-            correlation,
-          },
-        })
-      : await jobQueue!.enqueue('workflow-execution', payload, {
-          metadata: { workflowId, workspaceId, userId, correlation },
-        })
+    const jobQueue = await getJobQueue()
+    const jobId = await jobQueue.enqueue('workflow-execution', payload, {
+      metadata: { workflowId, workspaceId, userId, correlation },
+    })
 
     asyncLogger.info('Queued async workflow execution', { jobId })
 
-    if (shouldExecuteInline() && jobQueue) {
-      const inlineJobQueue = jobQueue
+    if (shouldExecuteInline()) {
       void (async () => {
         try {
-          await inlineJobQueue.startJob(jobId)
+          await jobQueue.startJob(jobId)
           const output = await executeWorkflowJob(payload)
-          await inlineJobQueue.completeJob(jobId, output)
+          await jobQueue.completeJob(jobId, output)
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error)
           asyncLogger.error('Async workflow execution failed', {
@@ -258,7 +224,7 @@ async function handleAsyncExecution(params: AsyncExecutionParams): Promise<NextR
             error: errorMessage,
           })
           try {
-            await inlineJobQueue.markJobFailed(jobId, errorMessage)
+            await jobQueue.markJobFailed(jobId, errorMessage)
           } catch (markFailedError) {
             asyncLogger.error('Failed to mark job as failed', {
               jobId,
@@ -284,17 +250,6 @@ async function handleAsyncExecution(params: AsyncExecutionParams): Promise<NextR
       { status: 202 }
     )
   } catch (error: any) {
-    if (error instanceof DispatchQueueFullError) {
-      return NextResponse.json(
-        {
-          error: 'Service temporarily at capacity',
-          message: error.message,
-          retryAfterSeconds: 10,
-        },
-        { status: 503, headers: { 'Retry-After': '10' } }
-      )
-    }
-
     asyncLogger.error('Failed to queue async execution', error)
     return NextResponse.json(
       { error: `Failed to queue async execution: ${error.message}` },
@@ -303,31 +258,6 @@ async function handleAsyncExecution(params: AsyncExecutionParams): Promise<NextR
   }
 }
 
-async function enqueueDirectWorkflowExecution(
-  payload: QueuedWorkflowExecutionPayload,
-  priority: number,
-  lane: WorkspaceDispatchLane
-) {
-  return enqueueWorkspaceDispatch({
-    id: payload.metadata.executionId,
-    workspaceId: payload.metadata.workspaceId,
-    lane,
-    queueName: 'workflow-execution',
-    bullmqJobName: DIRECT_WORKFLOW_JOB_NAME,
-    bullmqPayload: createBullMQJobData(payload, {
-      workflowId: payload.metadata.workflowId,
-      userId: payload.metadata.userId,
-      correlation: payload.metadata.correlation,
-    }),
-    metadata: {
-      workflowId: payload.metadata.workflowId,
-      userId: payload.metadata.userId,
-      correlation: payload.metadata.correlation,
-    },
-    priority,
-  })
-}
-
 /**
  * POST /api/workflows/[id]/execute
  *
@@ -452,6 +382,7 @@ async function handleExecutePost(
       includeFileBase64,
       base64MaxBytes,
       workflowStateOverride,
+      triggerBlockId,
       stopAfterBlockId,
       runFromBlock: rawRunFromBlock,
     } = validation.data
@@ -555,6 +486,7 @@ async function handleExecutePost(
               includeFileBase64,
               base64MaxBytes,
               workflowStateOverride,
+              triggerBlockId: _triggerBlockId,
               stopAfterBlockId: _stopAfterBlockId,
               runFromBlock: _runFromBlock,
               workflowId: _workflowId, // Also exclude workflowId used for internal JWT auth
@@ -585,6 +517,7 @@ async function handleExecutePost(
       (body.useDraftState !== undefined ||
         body.workflowStateOverride !== undefined ||
         body.runFromBlock !== undefined ||
+        body.triggerBlockId !== undefined ||
         body.stopAfterBlockId !== undefined ||
         body.selectedOutputs?.length ||
         body.includeFileBase64 !== undefined ||
@@ -785,6 +718,7 @@ async function handleExecutePost(
         sessionUserId: isClientSession ? userId : undefined,
         workflowUserId: workflow.userId,
         triggerType,
+        triggerBlockId,
         useDraftState: shouldUseDraftState,
         startTime: new Date().toISOString(),
         isClientSession,
@@ -796,92 +730,6 @@ async function handleExecutePost(
 
       const executionVariables = cachedWorkflowData?.variables ?? workflow.variables ?? {}
 
-      if (shouldUseBullMQ() && !INLINE_TRIGGER_TYPES.has(triggerType)) {
-        try {
-          const dispatchJobId = await enqueueDirectWorkflowExecution(
-            {
-              workflow,
-              metadata,
-              input: processedInput,
-              variables: executionVariables,
-              selectedOutputs,
-              includeFileBase64,
-              base64MaxBytes,
-              stopAfterBlockId,
-              timeoutMs: preprocessResult.executionTimeout?.sync,
-              runFromBlock: resolvedRunFromBlock,
-            },
-            5,
-            'interactive'
-          )
-
-          const resultRecord = await waitForDispatchJob(
-            dispatchJobId,
-            (preprocessResult.executionTimeout?.sync ?? 300000) + 30000
-          )
-
-          if (resultRecord.status === 'failed') {
-            return NextResponse.json(
-              {
-                success: false,
-                executionId,
-                error: resultRecord.error ?? 'Workflow execution failed',
-              },
-              { status: 500 }
-            )
-          }
-
-          const result = resultRecord.output as QueuedWorkflowExecutionResult
-
-          const resultForResponseBlock = {
-            success: result.success,
-            logs: result.logs,
-            output: result.output,
-          }
-
-          if (
-            auth.authType !== AuthType.INTERNAL_JWT &&
-            workflowHasResponseBlock(resultForResponseBlock)
-          ) {
-            return createHttpResponseFromBlock(resultForResponseBlock)
-          }
-
-          return NextResponse.json(
-            {
-              success: result.success,
-              executionId,
-              output: result.output,
-              error: result.error,
-              metadata: result.metadata,
-            },
-            { status: result.statusCode ?? 200 }
-          )
-        } catch (error: unknown) {
-          if (error instanceof DispatchQueueFullError) {
-            return NextResponse.json(
-              {
-                error: 'Service temporarily at capacity',
-                message: error.message,
-                retryAfterSeconds: 10,
-              },
-              { status: 503, headers: { 'Retry-After': '10' } }
-            )
-          }
-
-          const errorMessage = error instanceof Error ? error.message : 'Unknown error'
-
-          reqLogger.error(`Queued non-SSE execution failed: ${errorMessage}`)
-
-          return NextResponse.json(
-            {
-              success: false,
-              error: errorMessage,
-            },
-            { status: 500 }
-          )
-        }
-      }
-
       const timeoutController = createTimeoutAbortController(
         preprocessResult.executionTimeout?.sync
       )
@@ -998,54 +846,6 @@ async function handleExecutePost(
     }
 
     if (shouldUseDraftState) {
-      const shouldDispatchViaQueue = shouldUseBullMQ() && !INLINE_TRIGGER_TYPES.has(triggerType)
-      if (shouldDispatchViaQueue) {
-        const metadata: ExecutionMetadata = {
-          requestId,
-          executionId,
-          workflowId,
-          workspaceId,
-          userId: actorUserId,
-          sessionUserId: isClientSession ? userId : undefined,
-          workflowUserId: workflow.userId,
-          triggerType,
-          useDraftState: shouldUseDraftState,
-          startTime: new Date().toISOString(),
-          isClientSession,
-          enforceCredentialAccess: useAuthenticatedUserAsActor,
-          workflowStateOverride: effectiveWorkflowStateOverride,
-          callChain,
-          executionMode: 'sync',
-        }
-
-        const executionVariables = cachedWorkflowData?.variables ?? workflow.variables ?? {}
-
-        await enqueueDirectWorkflowExecution(
-          {
-            workflow,
-            metadata,
-            input: processedInput,
-            variables: executionVariables,
-            selectedOutputs,
-            includeFileBase64,
-            base64MaxBytes,
-            stopAfterBlockId,
-            timeoutMs: preprocessResult.executionTimeout?.sync,
-            runFromBlock: resolvedRunFromBlock,
-            streamEvents: true,
-          },
-          1,
-          'interactive'
-        )
-
-        return new NextResponse(createBufferedExecutionStream(executionId), {
-          headers: {
-            ...SSE_HEADERS,
-            'X-Execution-Id': executionId,
-          },
-        })
-      }
-
       reqLogger.info('Using SSE console log streaming (manual execution)')
     } else {
       reqLogger.info('Using streaming API response')
@@ -1327,6 +1127,7 @@ async function handleExecutePost(
             sessionUserId: isClientSession ? userId : undefined,
             workflowUserId: workflow.userId,
             triggerType,
+            triggerBlockId,
             useDraftState: shouldUseDraftState,
             startTime: new Date().toISOString(),
             isClientSession,
@@ -1524,17 +1325,6 @@ async function handleExecutePost(
       },
     })
   } catch (error: any) {
-    if (error instanceof DispatchQueueFullError) {
-      return NextResponse.json(
-        {
-          error: 'Service temporarily at capacity',
-          message: error.message,
-          retryAfterSeconds: 10,
-        },
-        { status: 503, headers: { 'Retry-After': '10' } }
-      )
-    }
-
     reqLogger.error('Failed to start workflow execution:', error)
     return NextResponse.json(
       { error: error.message || 'Failed to start workflow execution' },
diff --git a/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts b/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts
index 65543049416..6de747246d8 100644
--- a/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts
+++ b/apps/sim/app/api/workspaces/[id]/pptx/preview/route.ts
@@ -1,7 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { type NextRequest, NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
-import { generatePptxFromCode } from '@/lib/execution/pptx-vm'
+import { generatePptxFromCode } from '@/lib/execution/doc-vm'
 import { verifyWorkspaceMembership } from '@/app/api/workflows/utils'
 
 export const dynamic = 'force-dynamic'
diff --git a/apps/sim/app/changelog/components/timeline-list.tsx b/apps/sim/app/changelog/components/timeline-list.tsx
index e940bb98bbd..26c91197345 100644
--- a/apps/sim/app/changelog/components/timeline-list.tsx
+++ b/apps/sim/app/changelog/components/timeline-list.tsx
@@ -1,7 +1,8 @@
 'use client'
 
 import React from 'react'
-import ReactMarkdown from 'react-markdown'
+import { Streamdown } from 'streamdown'
+import 'streamdown/styles.css'
 import { Avatar, AvatarFallback, AvatarImage } from '@/components/emcn'
 import type { ChangelogEntry } from '@/app/changelog/components/changelog-content'
 
@@ -141,7 +142,8 @@ export default function ChangelogList({ initialEntries }: Props) {
           </div>
 
           <div className='max-w-none'>
-            <ReactMarkdown
+            <Streamdown
+              mode='static'
               components={{
                 h2: ({ children, ...props }) =>
                   isContributorsLabel(children) ? null : (
@@ -192,11 +194,8 @@ export default function ChangelogList({ initialEntries }: Props) {
                     {children}
                   </strong>
                 ),
-                code: ({ children, ...props }) => (
-                  <code
-                    className='rounded bg-[var(--landing-bg-elevated)] px-1 py-0.5 font-mono text-[var(--landing-text)] text-xs'
-                    {...props}
-                  >
+                inlineCode: ({ children }) => (
+                  <code className='rounded bg-[var(--landing-bg-elevated)] px-1 py-0.5 font-mono text-[var(--landing-text)] text-xs'>
                     {children}
                   </code>
                 ),
@@ -212,7 +211,7 @@ export default function ChangelogList({ initialEntries }: Props) {
               }}
             >
               {cleanMarkdown(entry.content)}
-            </ReactMarkdown>
+            </Streamdown>
           </div>
         </div>
       ))}
diff --git a/apps/sim/app/chat/components/message/components/markdown-renderer.tsx b/apps/sim/app/chat/components/message/components/markdown-renderer.tsx
index a62c901ae2f..48d4a144bdb 100644
--- a/apps/sim/app/chat/components/message/components/markdown-renderer.tsx
+++ b/apps/sim/app/chat/components/message/components/markdown-renderer.tsx
@@ -1,6 +1,6 @@
 import React, { type HTMLAttributes, memo, type ReactNode, useMemo } from 'react'
-import ReactMarkdown from 'react-markdown'
-import remarkGfm from 'remark-gfm'
+import { Streamdown } from 'streamdown'
+import 'streamdown/styles.css'
 import { Tooltip } from '@/components/emcn'
 import { CopyCodeButton } from '@/components/ui/copy-code-button'
 import { extractTextContent } from '@/lib/core/utils/react-node-text'
@@ -25,8 +25,6 @@ export function LinkWithPreview({ href, children }: { href: string; children: Re
   )
 }
 
-const REMARK_PLUGINS = [remarkGfm]
-
 function createCustomComponents(LinkComponent: typeof LinkWithPreview) {
   return {
     p: ({ children }: React.HTMLAttributes<HTMLParagraphElement>) => (
@@ -72,11 +70,7 @@ function createCustomComponents(LinkComponent: typeof LinkWithPreview) {
         {children}
       </ol>
     ),
-    li: ({
-      children,
-      ordered,
-      ...props
-    }: React.LiHTMLAttributes<HTMLLIElement> & { ordered?: boolean }) => (
+    li: ({ children }: React.LiHTMLAttributes<HTMLLIElement>) => (
       <li className='font-sans text-gray-800 dark:text-gray-200' style={{ display: 'list-item' }}>
         {children}
       </li>
@@ -116,28 +110,11 @@ function createCustomComponents(LinkComponent: typeof LinkWithPreview) {
       )
     },
 
-    code: ({
-      inline,
-      className,
-      children,
-      ...props
-    }: React.HTMLAttributes<HTMLElement> & { className?: string; inline?: boolean }) => {
-      if (inline) {
-        return (
-          <code
-            className='rounded bg-gray-200 px-1 py-0.5 font-mono text-[0.9em] text-gray-800 dark:bg-gray-700 dark:text-gray-200'
-            {...props}
-          >
-            {children}
-          </code>
-        )
-      }
-      return (
-        <code className={className} {...props}>
-          {children}
-        </code>
-      )
-    },
+    inlineCode: ({ children }: { children?: React.ReactNode }) => (
+      <code className='rounded bg-gray-200 px-1 py-0.5 font-mono text-gray-800 text-inherit dark:bg-gray-700 dark:text-gray-200'>
+        {children}
+      </code>
+    ),
 
     blockquote: ({ children }: React.HTMLAttributes<HTMLQuoteElement>) => (
       <blockquote className='my-4 border-gray-300 border-l-4 py-1 pl-4 font-sans text-gray-700 italic dark:border-gray-600 dark:text-gray-300'>
@@ -215,9 +192,9 @@ const MarkdownRenderer = memo(function MarkdownRenderer({
 
   return (
     <div className='space-y-4 break-words font-sans text-[var(--landing-text)] text-base leading-relaxed'>
-      <ReactMarkdown remarkPlugins={REMARK_PLUGINS} components={components}>
+      <Streamdown mode='static' components={components}>
         {processedContent}
-      </ReactMarkdown>
+      </Streamdown>
     </div>
   )
 })
diff --git a/apps/sim/app/templates/[id]/template.tsx b/apps/sim/app/templates/[id]/template.tsx
index 40ad9722a8c..b311837cdd8 100644
--- a/apps/sim/app/templates/[id]/template.tsx
+++ b/apps/sim/app/templates/[id]/template.tsx
@@ -14,7 +14,8 @@ import {
   User,
 } from 'lucide-react'
 import { useParams, useRouter, useSearchParams } from 'next/navigation'
-import ReactMarkdown from 'react-markdown'
+import { Streamdown } from 'streamdown'
+import 'streamdown/styles.css'
 import {
   Breadcrumb,
   Button,
@@ -875,7 +876,8 @@ export default function TemplateDetails({ isWorkspaceContext = false }: Template
                 About this Workflow
               </h3>
               <div className='max-w-none space-y-2'>
-                <ReactMarkdown
+                <Streamdown
+                  mode='static'
                   components={{
                     p: ({ children }) => (
                       <p className='mb-2 font-sans text-muted-foreground text-sm leading-[1.4rem] last:mb-0'>
@@ -913,16 +915,16 @@ export default function TemplateDetails({ isWorkspaceContext = false }: Template
                       </ol>
                     ),
                     li: ({ children }) => <li className='leading-[1.4rem]'>{children}</li>,
-                    code: ({ inline, children }: any) =>
-                      inline ? (
-                        <code className='rounded bg-muted px-1.5 py-0.5 font-mono text-[var(--caution)] text-xs'>
-                          {children}
-                        </code>
-                      ) : (
-                        <code className='my-2 block overflow-x-auto rounded-md bg-muted p-3 font-mono text-foreground text-xs'>
-                          {children}
-                        </code>
-                      ),
+                    inlineCode: ({ children }) => (
+                      <code className='rounded bg-muted px-1.5 py-0.5 font-mono text-[var(--caution)] text-xs'>
+                        {children}
+                      </code>
+                    ),
+                    code: ({ children }) => (
+                      <code className='my-2 block overflow-x-auto rounded-md bg-muted p-3 font-mono text-foreground text-xs'>
+                        {children}
+                      </code>
+                    ),
                     a: ({ href, children }) => (
                       <a
                         href={href}
@@ -942,7 +944,7 @@ export default function TemplateDetails({ isWorkspaceContext = false }: Template
                   }}
                 >
                   {template.details.about}
-                </ReactMarkdown>
+                </Streamdown>
               </div>
             </div>
           )}
@@ -1056,7 +1058,8 @@ export default function TemplateDetails({ isWorkspaceContext = false }: Template
                     {/* Creator bio */}
                     {template.creator.details?.about && (
                       <div className='max-w-none'>
-                        <ReactMarkdown
+                        <Streamdown
+                          mode='static'
                           components={{
                             p: ({ children }) => (
                               <p className='mb-2 font-sans text-muted-foreground text-sm leading-[1.4rem] last:mb-0'>
@@ -1081,7 +1084,7 @@ export default function TemplateDetails({ isWorkspaceContext = false }: Template
                           }}
                         >
                           {template.creator.details.about}
-                        </ReactMarkdown>
+                        </Streamdown>
                       </div>
                     )}
                   </div>
diff --git a/apps/sim/app/workspace/[workspaceId]/components/message-actions/message-actions.tsx b/apps/sim/app/workspace/[workspaceId]/components/message-actions/message-actions.tsx
index 77607befa95..67c7dd92c8f 100644
--- a/apps/sim/app/workspace/[workspaceId]/components/message-actions/message-actions.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/components/message-actions/message-actions.tsx
@@ -13,6 +13,7 @@ import {
   Textarea,
   ThumbsDown,
   ThumbsUp,
+  Tooltip,
 } from '@/components/emcn'
 import { useSubmitCopilotFeedback } from '@/hooks/queries/copilot-feedback'
 
@@ -46,13 +47,16 @@ interface MessageActionsProps {
   content: string
   chatId?: string
   userQuery?: string
+  requestId?: string
 }
 
-export function MessageActions({ content, chatId, userQuery }: MessageActionsProps) {
+export function MessageActions({ content, chatId, userQuery, requestId }: MessageActionsProps) {
   const [copied, setCopied] = useState(false)
+  const [copiedRequestId, setCopiedRequestId] = useState(false)
   const [pendingFeedback, setPendingFeedback] = useState<'up' | 'down' | null>(null)
   const [feedbackText, setFeedbackText] = useState('')
   const resetTimeoutRef = useRef<number | null>(null)
+  const requestIdTimeoutRef = useRef<number | null>(null)
   const submitFeedback = useSubmitCopilotFeedback()
 
   useEffect(() => {
@@ -60,6 +64,9 @@ export function MessageActions({ content, chatId, userQuery }: MessageActionsPro
       if (resetTimeoutRef.current !== null) {
         window.clearTimeout(resetTimeoutRef.current)
       }
+      if (requestIdTimeoutRef.current !== null) {
+        window.clearTimeout(requestIdTimeoutRef.current)
+      }
     }
   }, [])
 
@@ -79,11 +86,26 @@ export function MessageActions({ content, chatId, userQuery }: MessageActionsPro
     }
   }, [content])
 
+  const copyRequestId = useCallback(async () => {
+    if (!requestId) return
+    try {
+      await navigator.clipboard.writeText(requestId)
+      setCopiedRequestId(true)
+      if (requestIdTimeoutRef.current !== null) {
+        window.clearTimeout(requestIdTimeoutRef.current)
+      }
+      requestIdTimeoutRef.current = window.setTimeout(() => setCopiedRequestId(false), 1500)
+    } catch {
+      /* clipboard unavailable */
+    }
+  }, [requestId])
+
   const handleFeedbackClick = useCallback(
     (type: 'up' | 'down') => {
       if (chatId && userQuery) {
         setPendingFeedback(type)
         setFeedbackText('')
+        setCopiedRequestId(false)
       }
     },
     [chatId, userQuery]
@@ -112,6 +134,7 @@ export function MessageActions({ content, chatId, userQuery }: MessageActionsPro
     if (!open) {
       setPendingFeedback(null)
       setFeedbackText('')
+      setCopiedRequestId(false)
     }
   }, [])
 
@@ -151,9 +174,32 @@ export function MessageActions({ content, chatId, userQuery }: MessageActionsPro
           <ModalHeader>Give feedback</ModalHeader>
           <ModalBody>
             <div className='flex flex-col gap-2'>
-              <p className='font-medium text-[var(--text-secondary)] text-sm'>
-                {pendingFeedback === 'up' ? 'What did you like?' : 'What could be improved?'}
-              </p>
+              <div className='flex items-start justify-between gap-2'>
+                <p className='font-medium text-[var(--text-secondary)] text-sm'>
+                  {pendingFeedback === 'up' ? 'What did you like?' : 'What could be improved?'}
+                </p>
+                {pendingFeedback === 'down' && requestId && (
+                  <Tooltip.Root>
+                    <Tooltip.Trigger asChild>
+                      <button
+                        type='button'
+                        aria-label='Copy request ID'
+                        onClick={copyRequestId}
+                        className='flex h-[22px] w-[22px] shrink-0 items-center justify-center rounded-full text-[var(--text-icon)] transition-colors hover-hover:bg-[var(--surface-hover)] focus-visible:outline-none'
+                      >
+                        {copiedRequestId ? (
+                          <Check className='h-[14px] w-[14px]' />
+                        ) : (
+                          <Copy className='h-[14px] w-[14px]' />
+                        )}
+                      </button>
+                    </Tooltip.Trigger>
+                    <Tooltip.Content side='top'>
+                      {copiedRequestId ? 'Copied request ID' : 'Copy request ID'}
+                    </Tooltip.Content>
+                  </Tooltip.Root>
+                )}
+              </div>
               <Textarea
                 placeholder={
                   pendingFeedback === 'up'
diff --git a/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx b/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx
index a450bd374da..cbed424d13b 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx
@@ -17,7 +17,7 @@ export function FileViewer() {
     return null
   }
 
-  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace`
+  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace&t=${file.size}`
 
   return (
     <div className='fixed inset-0 z-50 bg-[var(--bg)]'>
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
index f62caa1f51c..f190d8fa6e1 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx
@@ -1,9 +1,33 @@
 'use client'
 
-import { memo, useCallback, useEffect, useRef, useState } from 'react'
+import {
+  memo,
+  type ReactElement,
+  useCallback,
+  useEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+} from 'react'
+import Editor from 'react-simple-code-editor'
+import 'prismjs/components/prism-bash'
+import 'prismjs/components/prism-css'
+import 'prismjs/components/prism-markup'
+import 'prismjs/components/prism-sql'
+import 'prismjs/components/prism-typescript'
+import 'prismjs/components/prism-yaml'
 import { createLogger } from '@sim/logger'
 import { ZoomIn, ZoomOut } from 'lucide-react'
-import { Skeleton } from '@/components/emcn'
+import {
+  CODE_LINE_HEIGHT_PX,
+  Code as CodeEditor,
+  calculateGutterWidth,
+  getCodeEditorProps,
+  highlight,
+  languages,
+  Skeleton,
+} from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace'
 import { getFileExtension } from '@/lib/uploads/utils/file-utils'
@@ -14,7 +38,6 @@ import {
   useWorkspaceFileContent,
 } from '@/hooks/queries/workspace-files'
 import { useAutosave } from '@/hooks/use-autosave'
-import { useStreamingText } from '@/hooks/use-streaming-text'
 import { DataTable } from './data-table'
 import { PreviewPanel, resolvePreviewType } from './preview-panel'
 
@@ -57,7 +80,7 @@ const TEXT_EDITABLE_EXTENSIONS = new Set([
   ...SUPPORTED_CODE_EXTENSIONS,
 ])
 
-const IFRAME_PREVIEWABLE_MIME_TYPES = new Set(['application/pdf'])
+const IFRAME_PREVIEWABLE_MIME_TYPES = new Set(['application/pdf', 'text/x-pdflibjs'])
 const IFRAME_PREVIEWABLE_EXTENSIONS = new Set(['pdf'])
 
 const IMAGE_PREVIEWABLE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp'])
@@ -65,11 +88,13 @@ const IMAGE_PREVIEWABLE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp
 
 const PPTX_PREVIEWABLE_MIME_TYPES = new Set([
   'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  'text/x-pptxgenjs',
 ])
 const PPTX_PREVIEWABLE_EXTENSIONS = new Set(['pptx'])
 
 const DOCX_PREVIEWABLE_MIME_TYPES = new Set([
   'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  'text/x-docxjs',
 ])
 const DOCX_PREVIEWABLE_EXTENSIONS = new Set(['docx'])
 
@@ -87,12 +112,65 @@ type FileCategory =
   | 'xlsx-previewable'
   | 'unsupported'
 
+type CodeEditorLanguage =
+  | 'javascript'
+  | 'json'
+  | 'python'
+  | 'typescript'
+  | 'bash'
+  | 'css'
+  | 'markup'
+  | 'sql'
+  | 'yaml'
+
+const CODE_EDITOR_LANGUAGE_BY_EXTENSION: Partial<Record<string, CodeEditorLanguage>> = {
+  js: 'javascript',
+  jsx: 'javascript',
+  ts: 'typescript',
+  tsx: 'typescript',
+  py: 'python',
+  json: 'json',
+  sh: 'bash',
+  bash: 'bash',
+  zsh: 'bash',
+  fish: 'bash',
+  css: 'css',
+  scss: 'css',
+  less: 'css',
+  html: 'markup',
+  htm: 'markup',
+  xml: 'markup',
+  svg: 'markup',
+  sql: 'sql',
+  yaml: 'yaml',
+  yml: 'yaml',
+}
+
+const CODE_EDITOR_LANGUAGE_BY_MIME: Partial<Record<string, CodeEditorLanguage>> = {
+  'text/javascript': 'javascript',
+  'application/javascript': 'javascript',
+  'text/typescript': 'typescript',
+  'application/typescript': 'typescript',
+  'text/x-python': 'python',
+  'application/json': 'json',
+  'text/x-shellscript': 'bash',
+  'text/css': 'css',
+  'text/html': 'markup',
+  'text/xml': 'markup',
+  'application/xml': 'markup',
+  'image/svg+xml': 'markup',
+  'text/x-sql': 'sql',
+  'application/x-yaml': 'yaml',
+}
+
+const CODE_EDITOR_LINE_HEIGHT_PX = CODE_LINE_HEIGHT_PX
+
 function resolveFileCategory(mimeType: string | null, filename: string): FileCategory {
   if (mimeType && TEXT_EDITABLE_MIME_TYPES.has(mimeType)) return 'text-editable'
   if (mimeType && IFRAME_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'iframe-previewable'
   if (mimeType && IMAGE_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'image-previewable'
-  if (mimeType && PPTX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'pptx-previewable'
   if (mimeType && DOCX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'docx-previewable'
+  if (mimeType && PPTX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'pptx-previewable'
   if (mimeType && XLSX_PREVIEWABLE_MIME_TYPES.has(mimeType)) return 'xlsx-previewable'
 
   const ext = getFileExtension(filename)
@@ -100,8 +178,8 @@ function resolveFileCategory(mimeType: string | null, filename: string): FileCat
   if (TEXT_EDITABLE_EXTENSIONS.has(nameKey)) return 'text-editable'
   if (IFRAME_PREVIEWABLE_EXTENSIONS.has(ext)) return 'iframe-previewable'
   if (IMAGE_PREVIEWABLE_EXTENSIONS.has(ext)) return 'image-previewable'
-  if (PPTX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'pptx-previewable'
   if (DOCX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'docx-previewable'
+  if (PPTX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'pptx-previewable'
   if (XLSX_PREVIEWABLE_EXTENSIONS.has(ext)) return 'xlsx-previewable'
 
   return 'unsupported'
@@ -116,6 +194,7 @@ export function isPreviewable(file: { type: string; name: string }): boolean {
 }
 
 export type PreviewMode = 'editor' | 'split' | 'preview'
+type StreamingMode = 'append' | 'replace'
 
 interface FileViewerProps {
   file: WorkspaceFileRecord
@@ -128,6 +207,286 @@ interface FileViewerProps {
   onSaveStatusChange?: (status: 'idle' | 'saving' | 'saved' | 'error') => void
   saveRef?: React.MutableRefObject<(() => Promise<void>) | null>
   streamingContent?: string
+  streamingMode?: StreamingMode
+  disableStreamingAutoScroll?: boolean
+  useCodeRendererForCodeFiles?: boolean
+  previewContextKey?: string
+}
+
+function isCodeFile(file: { type: string; name: string }): boolean {
+  const ext = getFileExtension(file.name)
+  return (
+    SUPPORTED_CODE_EXTENSIONS.includes(ext as (typeof SUPPORTED_CODE_EXTENSIONS)[number]) ||
+    ext === 'html' ||
+    ext === 'htm' ||
+    ext === 'xml' ||
+    ext === 'svg'
+  )
+}
+
+function resolveCodeEditorLanguage(file: { type: string; name: string }): CodeEditorLanguage {
+  const ext = getFileExtension(file.name)
+  return (
+    CODE_EDITOR_LANGUAGE_BY_EXTENSION[ext] ??
+    CODE_EDITOR_LANGUAGE_BY_MIME[file.type] ??
+    (ext === 'json' ? 'json' : 'javascript')
+  )
+}
+
+function areNumberArraysEqual(a: number[], b: number[]): boolean {
+  if (a === b) return true
+  if (a.length !== b.length) return false
+  for (let index = 0; index < a.length; index++) {
+    if (a[index] !== b[index]) {
+      return false
+    }
+  }
+  return true
+}
+
+type TextEditorContentPhase = 'uninitialized' | 'ready' | 'streaming' | 'reconciling'
+
+interface TextEditorContentState {
+  phase: TextEditorContentPhase
+  content: string
+  savedContent: string
+  lastStreamedContent: string | null
+}
+
+interface SyncTextEditorContentStateOptions {
+  canReconcileToFetchedContent: boolean
+  fetchedContent?: string
+  streamingContent?: string
+  streamingMode: StreamingMode
+}
+
+type TextEditorContentAction =
+  | ({ type: 'sync-external' } & SyncTextEditorContentStateOptions)
+  | { type: 'edit'; content: string }
+  | { type: 'save-success'; content: string }
+
+const INITIAL_TEXT_EDITOR_CONTENT_STATE: TextEditorContentState = {
+  phase: 'uninitialized',
+  content: '',
+  savedContent: '',
+  lastStreamedContent: null,
+}
+
+function resolveStreamingEditorContent(
+  fetchedContent: string | undefined,
+  streamingContent: string,
+  streamingMode: StreamingMode
+): string {
+  if (streamingMode === 'replace' || fetchedContent === undefined) {
+    return streamingContent
+  }
+
+  if (
+    fetchedContent.endsWith(streamingContent) ||
+    fetchedContent.endsWith(`\n${streamingContent}`)
+  ) {
+    return fetchedContent
+  }
+
+  return `${fetchedContent}\n${streamingContent}`
+}
+
+function finalizeTextEditorContentState(
+  state: TextEditorContentState,
+  nextContent: string
+): TextEditorContentState {
+  if (
+    state.phase === 'ready' &&
+    state.content === nextContent &&
+    state.savedContent === nextContent &&
+    state.lastStreamedContent === null
+  ) {
+    return state
+  }
+
+  return {
+    phase: 'ready',
+    content: nextContent,
+    savedContent: nextContent,
+    lastStreamedContent: null,
+  }
+}
+
+function moveTextEditorContentStateToStreaming(
+  state: TextEditorContentState,
+  nextContent: string
+): TextEditorContentState {
+  if (
+    state.phase === 'streaming' &&
+    state.content === nextContent &&
+    state.lastStreamedContent === nextContent
+  ) {
+    return state
+  }
+
+  return {
+    ...state,
+    phase: 'streaming',
+    content: nextContent,
+    lastStreamedContent: nextContent,
+  }
+}
+
+function moveTextEditorContentStateToReconcile(
+  state: TextEditorContentState
+): TextEditorContentState {
+  if (state.phase === 'reconciling') {
+    return state
+  }
+
+  return {
+    ...state,
+    phase: 'reconciling',
+  }
+}
+
+function syncTextEditorContentState(
+  state: TextEditorContentState,
+  options: SyncTextEditorContentStateOptions
+): TextEditorContentState {
+  const { canReconcileToFetchedContent, fetchedContent, streamingContent, streamingMode } = options
+
+  if (streamingContent !== undefined) {
+    const nextContent = resolveStreamingEditorContent(
+      fetchedContent,
+      streamingContent,
+      streamingMode
+    )
+    const fetchedMatchesNextContent = fetchedContent !== undefined && fetchedContent === nextContent
+    const fetchedMatchesLastStreamedContent =
+      fetchedContent !== undefined &&
+      state.lastStreamedContent !== null &&
+      fetchedContent === state.lastStreamedContent
+    const hasFetchedAdvanced = fetchedContent !== undefined && fetchedContent !== state.savedContent
+
+    if (
+      (state.phase === 'streaming' || state.phase === 'reconciling') &&
+      (hasFetchedAdvanced || fetchedMatchesLastStreamedContent || fetchedMatchesNextContent)
+    ) {
+      return finalizeTextEditorContentState(state, fetchedContent)
+    }
+
+    if (
+      state.phase === 'ready' &&
+      state.content === state.savedContent &&
+      fetchedMatchesNextContent &&
+      fetchedContent !== undefined
+    ) {
+      return finalizeTextEditorContentState(state, fetchedContent)
+    }
+
+    return moveTextEditorContentStateToStreaming(state, nextContent)
+  }
+
+  if (state.phase === 'streaming' || state.phase === 'reconciling') {
+    if (!canReconcileToFetchedContent) {
+      return finalizeTextEditorContentState(state, state.content)
+    }
+
+    if (fetchedContent !== undefined) {
+      const hasFetchedAdvanced = fetchedContent !== state.savedContent
+      const fetchedMatchesLastStreamedContent =
+        state.lastStreamedContent !== null && fetchedContent === state.lastStreamedContent
+
+      if (hasFetchedAdvanced || fetchedMatchesLastStreamedContent) {
+        return finalizeTextEditorContentState(state, fetchedContent)
+      }
+    }
+
+    return moveTextEditorContentStateToReconcile(state)
+  }
+
+  if (fetchedContent === undefined) {
+    return state
+  }
+
+  if (state.phase === 'uninitialized') {
+    return finalizeTextEditorContentState(state, fetchedContent)
+  }
+
+  if (fetchedContent === state.savedContent) {
+    return state
+  }
+
+  if (state.content === state.savedContent) {
+    return finalizeTextEditorContentState(state, fetchedContent)
+  }
+
+  return state
+}
+
+function textEditorContentReducer(
+  state: TextEditorContentState,
+  action: TextEditorContentAction
+): TextEditorContentState {
+  switch (action.type) {
+    case 'sync-external':
+      return syncTextEditorContentState(state, action)
+    case 'edit':
+      if (state.phase !== 'ready' || action.content === state.content) {
+        return state
+      }
+      return {
+        ...state,
+        content: action.content,
+      }
+    case 'save-success':
+      if (
+        state.phase === 'ready' &&
+        state.content === action.content &&
+        state.savedContent === action.content &&
+        state.lastStreamedContent === null
+      ) {
+        return state
+      }
+      return {
+        ...state,
+        phase: 'ready',
+        content: action.content,
+        savedContent: action.content,
+        lastStreamedContent: null,
+      }
+    default:
+      return state
+  }
+}
+
+function useTextEditorContentState(options: SyncTextEditorContentStateOptions) {
+  const [state, dispatch] = useReducer(textEditorContentReducer, INITIAL_TEXT_EDITOR_CONTENT_STATE)
+
+  useEffect(() => {
+    dispatch({
+      type: 'sync-external',
+      ...options,
+    })
+  }, [
+    options.canReconcileToFetchedContent,
+    options.fetchedContent,
+    options.streamingContent,
+    options.streamingMode,
+  ])
+
+  const setDraftContent = useCallback((content: string) => {
+    dispatch({ type: 'edit', content })
+  }, [])
+
+  const markSavedContent = useCallback((content: string) => {
+    dispatch({ type: 'save-success', content })
+  }, [])
+
+  return {
+    content: state.content,
+    savedContent: state.savedContent,
+    isInitialized: state.phase !== 'uninitialized',
+    isStreamInteractionLocked: state.phase === 'streaming' || state.phase === 'reconciling',
+    setDraftContent,
+    markSavedContent,
+  }
 }
 
 export function FileViewer({
@@ -141,6 +500,10 @@ export function FileViewer({
   onSaveStatusChange,
   saveRef,
   streamingContent,
+  streamingMode,
+  disableStreamingAutoScroll = false,
+  useCodeRendererForCodeFiles = false,
+  previewContextKey,
 }: FileViewerProps) {
   const category = resolveFileCategory(file.type, file.name)
 
@@ -149,31 +512,37 @@ export function FileViewer({
       <TextEditor
         file={file}
         workspaceId={workspaceId}
-        canEdit={streamingContent !== undefined ? false : canEdit}
+        canEdit={canEdit}
         previewMode={previewMode ?? (showPreview ? 'preview' : 'editor')}
         autoFocus={autoFocus}
         onDirtyChange={onDirtyChange}
         onSaveStatusChange={onSaveStatusChange}
         saveRef={saveRef}
         streamingContent={streamingContent}
+        streamingMode={streamingMode}
+        disableStreamingAutoScroll={disableStreamingAutoScroll}
+        useCodeRendererForCodeFiles={useCodeRendererForCodeFiles}
+        previewContextKey={previewContextKey}
       />
     )
   }
 
   if (category === 'iframe-previewable') {
-    return <IframePreview file={file} />
+    return (
+      <IframePreview file={file} workspaceId={workspaceId} streamingContent={streamingContent} />
+    )
   }
 
   if (category === 'image-previewable') {
-    return <ImagePreview file={file} />
+    return <ImagePreview file={file} workspaceId={workspaceId} />
   }
 
-  if (category === 'pptx-previewable') {
-    return <PptxPreview file={file} workspaceId={workspaceId} streamingContent={streamingContent} />
+  if (category === 'docx-previewable') {
+    return <DocxPreview file={file} workspaceId={workspaceId} streamingContent={streamingContent} />
   }
 
-  if (category === 'docx-previewable') {
-    return <DocxPreview file={file} workspaceId={workspaceId} />
+  if (category === 'pptx-previewable') {
+    return <PptxPreview file={file} workspaceId={workspaceId} streamingContent={streamingContent} />
   }
 
   if (category === 'xlsx-previewable') {
@@ -193,6 +562,10 @@ interface TextEditorProps {
   onSaveStatusChange?: (status: 'idle' | 'saving' | 'saved' | 'error') => void
   saveRef?: React.MutableRefObject<(() => Promise<void>) | null>
   streamingContent?: string
+  streamingMode?: StreamingMode
+  disableStreamingAutoScroll: boolean
+  useCodeRendererForCodeFiles?: boolean
+  previewContextKey?: string
 }
 
 function TextEditor({
@@ -205,103 +578,125 @@ function TextEditor({
   onSaveStatusChange,
   saveRef,
   streamingContent,
+  streamingMode = 'append',
+  disableStreamingAutoScroll,
+  useCodeRendererForCodeFiles = false,
+  previewContextKey,
 }: TextEditorProps) {
-  const initializedRef = useRef(false)
-  const contentRef = useRef('')
   const textareaRef = useRef<HTMLTextAreaElement>(null)
   const containerRef = useRef<HTMLDivElement>(null)
+  const codeEditorRef = useRef<HTMLDivElement>(null)
+  const codeScrollRef = useRef<HTMLDivElement>(null)
+  const hasAutoFocusedRef = useRef(false)
 
   const [splitPct, setSplitPct] = useState(SPLIT_DEFAULT_PCT)
   const [isResizing, setIsResizing] = useState(false)
+  const [visualLineHeights, setVisualLineHeights] = useState<number[]>([])
+  const [activeLineNumber, setActiveLineNumber] = useState(1)
 
   const {
     data: fetchedContent,
     isLoading,
     error,
-    dataUpdatedAt,
-  } = useWorkspaceFileContent(workspaceId, file.id, file.key, file.type === 'text/x-pptxgenjs')
+  } = useWorkspaceFileContent(
+    workspaceId,
+    file.id,
+    file.key,
+    file.type === 'text/x-pptxgenjs' ||
+      file.type === 'text/x-docxjs' ||
+      file.type === 'text/x-pdflibjs'
+  )
 
   const updateContent = useUpdateWorkspaceFileContent()
   const updateContentRef = useRef(updateContent)
   updateContentRef.current = updateContent
 
-  const [content, setContent] = useState('')
-  const [savedContent, setSavedContent] = useState('')
-  const savedContentRef = useRef('')
+  const shouldUseCodeRenderer = useCodeRendererForCodeFiles && isCodeFile(file)
+  const codeLanguage = useMemo(() => resolveCodeEditorLanguage(file), [file.name, file.type])
+  const onDirtyChangeRef = useRef(onDirtyChange)
+  const onSaveStatusChangeRef = useRef(onSaveStatusChange)
+  onDirtyChangeRef.current = onDirtyChange
+  onSaveStatusChangeRef.current = onSaveStatusChange
+
+  const {
+    content,
+    savedContent,
+    isInitialized,
+    isStreamInteractionLocked,
+    setDraftContent,
+    markSavedContent,
+  } = useTextEditorContentState({
+    canReconcileToFetchedContent: file.key.length > 0,
+    fetchedContent,
+    streamingContent,
+    streamingMode,
+  })
 
   useEffect(() => {
-    if (streamingContent !== undefined) {
-      setContent(streamingContent)
-      contentRef.current = streamingContent
-      initializedRef.current = true
+    if (!autoFocus || !isInitialized || hasAutoFocusedRef.current) {
       return
     }
 
-    if (fetchedContent === undefined) return
-
-    if (!initializedRef.current) {
-      setContent(fetchedContent)
-      setSavedContent(fetchedContent)
-      savedContentRef.current = fetchedContent
-      contentRef.current = fetchedContent
-      initializedRef.current = true
-
-      if (autoFocus) {
-        requestAnimationFrame(() => textareaRef.current?.focus())
+    hasAutoFocusedRef.current = true
+    requestAnimationFrame(() => {
+      const editorTextarea = codeEditorRef.current?.querySelector('textarea')
+      if (editorTextarea instanceof HTMLTextAreaElement) {
+        editorTextarea.focus()
+        return
       }
-      return
-    }
-
-    if (fetchedContent === savedContentRef.current) return
-    const isClean = contentRef.current === savedContentRef.current
-    if (isClean) {
-      setContent(fetchedContent)
-      setSavedContent(fetchedContent)
-      savedContentRef.current = fetchedContent
-      contentRef.current = fetchedContent
-    }
-  }, [streamingContent, fetchedContent, dataUpdatedAt, autoFocus])
+      textareaRef.current?.focus()
+    })
+  }, [autoFocus, isInitialized])
 
-  const handleContentChange = useCallback((value: string) => {
-    setContent(value)
-    contentRef.current = value
-  }, [])
+  const handleContentChange = useCallback(
+    (value: string) => {
+      if (value === content) {
+        return
+      }
+      setDraftContent(value)
+    },
+    [content, setDraftContent]
+  )
 
   const onSave = useCallback(async () => {
-    const currentContent = contentRef.current
-    if (currentContent === savedContentRef.current) return
+    if (content === savedContent) return
 
     await updateContentRef.current.mutateAsync({
       workspaceId,
       fileId: file.id,
-      content: currentContent,
+      content,
     })
-    setSavedContent(currentContent)
-    savedContentRef.current = currentContent
-  }, [workspaceId, file.id])
+    markSavedContent(content)
+  }, [content, file.id, markSavedContent, savedContent, workspaceId])
 
   const { saveStatus, saveImmediately, isDirty } = useAutosave({
     content,
     savedContent,
     onSave,
-    enabled: canEdit && initializedRef.current,
+    enabled: canEdit && isInitialized && !isStreamInteractionLocked,
   })
 
   useEffect(() => {
-    onDirtyChange?.(isDirty)
-  }, [isDirty, onDirtyChange])
+    onDirtyChangeRef.current?.(isDirty)
+  }, [isDirty])
 
   useEffect(() => {
-    onSaveStatusChange?.(saveStatus)
-  }, [saveStatus, onSaveStatusChange])
+    onSaveStatusChangeRef.current?.(saveStatus)
+  }, [saveStatus])
 
-  if (saveRef) saveRef.current = saveImmediately
-  useEffect(
-    () => () => {
-      if (saveRef) saveRef.current = null
-    },
-    [saveRef]
-  )
+  useEffect(() => {
+    if (!saveRef) {
+      return
+    }
+
+    saveRef.current = saveImmediately
+
+    return () => {
+      if (saveRef.current === saveImmediately) {
+        saveRef.current = null
+      }
+    }
+  }, [saveImmediately, saveRef])
 
   useEffect(() => {
     if (!isResizing) return
@@ -331,28 +726,186 @@ function TextEditor({
 
   const handleCheckboxToggle = useCallback(
     (checkboxIndex: number, checked: boolean) => {
-      const toggled = toggleMarkdownCheckbox(contentRef.current, checkboxIndex, checked)
-      if (toggled !== contentRef.current) {
+      const toggled = toggleMarkdownCheckbox(content, checkboxIndex, checked)
+      if (toggled !== content) {
         handleContentChange(toggled)
       }
     },
-    [handleContentChange]
+    [content, handleContentChange]
   )
 
-  const isStreaming = streamingContent !== undefined
-  const revealedContent = useStreamingText(content, isStreaming)
+  const isStreaming = isStreamInteractionLocked
+  const isEditorReadOnly = isStreamInteractionLocked || !canEdit
+  const renderedContent = content
+  const gutterWidthPx = useMemo(() => {
+    const lineCount = renderedContent.split('\n').length
+    return calculateGutterWidth(lineCount)
+  }, [renderedContent])
+  const sharedCodeEditorProps = useMemo(
+    () =>
+      getCodeEditorProps({
+        disabled: isEditorReadOnly,
+        isStreaming: isStreaming,
+      }),
+    [isEditorReadOnly, isStreaming]
+  )
+  const highlightCode = useMemo(() => {
+    return (value: string) => {
+      const grammar = languages[codeLanguage] || languages.javascript
+      return highlight(value, grammar, codeLanguage)
+    }
+  }, [codeLanguage])
+  const handleCodeContentChange = useCallback(
+    (value: string) => {
+      if (isEditorReadOnly) return
+      handleContentChange(value)
+    },
+    [handleContentChange, isEditorReadOnly]
+  )
 
   const textareaStuckRef = useRef(true)
 
+  useEffect(() => {
+    if (!shouldUseCodeRenderer) return
+    const textarea = codeEditorRef.current?.querySelector('textarea')
+    if (!(textarea instanceof HTMLTextAreaElement)) return
+
+    const updateActiveLineNumber = () => {
+      const pos = textarea.selectionStart
+      const textBeforeCursor = renderedContent.substring(0, pos)
+      const nextActiveLineNumber = textBeforeCursor.split('\n').length
+      setActiveLineNumber((currentLineNumber) =>
+        currentLineNumber === nextActiveLineNumber ? currentLineNumber : nextActiveLineNumber
+      )
+    }
+
+    updateActiveLineNumber()
+    textarea.addEventListener('click', updateActiveLineNumber)
+    textarea.addEventListener('keyup', updateActiveLineNumber)
+    textarea.addEventListener('focus', updateActiveLineNumber)
+
+    return () => {
+      textarea.removeEventListener('click', updateActiveLineNumber)
+      textarea.removeEventListener('keyup', updateActiveLineNumber)
+      textarea.removeEventListener('focus', updateActiveLineNumber)
+    }
+  }, [renderedContent, shouldUseCodeRenderer])
+
+  useEffect(() => {
+    if (!shouldUseCodeRenderer || !codeEditorRef.current) return
+
+    const calculateVisualLines = () => {
+      const preElement = codeEditorRef.current?.querySelector('pre')
+      if (!(preElement instanceof HTMLElement)) return
+
+      const lines = renderedContent.split('\n')
+      const newVisualLineHeights: number[] = []
+
+      const tempContainer = document.createElement('div')
+      tempContainer.style.cssText = `
+        position: absolute;
+        visibility: hidden;
+        height: auto;
+        width: ${preElement.clientWidth}px;
+        font-family: ${window.getComputedStyle(preElement).fontFamily};
+        font-size: ${window.getComputedStyle(preElement).fontSize};
+        line-height: ${CODE_EDITOR_LINE_HEIGHT_PX}px;
+        padding: 8px;
+        white-space: pre-wrap;
+        word-break: break-word;
+        box-sizing: border-box;
+      `
+      document.body.appendChild(tempContainer)
+
+      lines.forEach((line) => {
+        const lineDiv = document.createElement('div')
+        lineDiv.textContent = line || ' '
+        tempContainer.appendChild(lineDiv)
+        const actualHeight = lineDiv.getBoundingClientRect().height
+        const lineUnits = Math.max(1, Math.ceil(actualHeight / CODE_EDITOR_LINE_HEIGHT_PX))
+        newVisualLineHeights.push(lineUnits)
+        tempContainer.removeChild(lineDiv)
+      })
+
+      document.body.removeChild(tempContainer)
+      setVisualLineHeights((currentVisualLineHeights) =>
+        areNumberArraysEqual(currentVisualLineHeights, newVisualLineHeights)
+          ? currentVisualLineHeights
+          : newVisualLineHeights
+      )
+    }
+
+    const timeoutId = setTimeout(calculateVisualLines, 50)
+    const resizeObserver = new ResizeObserver(calculateVisualLines)
+    resizeObserver.observe(codeEditorRef.current)
+
+    return () => {
+      clearTimeout(timeoutId)
+      resizeObserver.disconnect()
+    }
+  }, [renderedContent, shouldUseCodeRenderer])
+
+  const renderCodeLineNumbers = useCallback((): ReactElement[] => {
+    const numbers: ReactElement[] = []
+    let lineNumber = 1
+
+    visualLineHeights.forEach((height) => {
+      const isActive = lineNumber === activeLineNumber
+      numbers.push(
+        <div
+          key={`${lineNumber}-0`}
+          className={cn(
+            'text-right text-xs tabular-nums leading-[21px]',
+            isActive
+              ? 'text-[var(--text-primary)] dark:text-[var(--code-foreground)]'
+              : 'text-[var(--text-muted)] dark:text-[var(--code-line-number)]'
+          )}
+        >
+          {lineNumber}
+        </div>
+      )
+
+      for (let i = 1; i < height; i++) {
+        numbers.push(
+          <div
+            key={`${lineNumber}-${i}`}
+            className='invisible text-right text-xs tabular-nums leading-[21px]'
+          >
+            {lineNumber}
+          </div>
+        )
+      }
+
+      lineNumber++
+    })
+
+    if (numbers.length === 0) {
+      numbers.push(
+        <div
+          key='1-0'
+          className='text-right text-[var(--text-muted)] text-xs tabular-nums leading-[21px] dark:text-[var(--code-line-number)]'
+        >
+          1
+        </div>
+      )
+    }
+
+    return numbers
+  }, [activeLineNumber, visualLineHeights])
+
   useEffect(() => {
     if (!isStreaming) return
+    if (disableStreamingAutoScroll) {
+      textareaStuckRef.current = false
+      return
+    }
     textareaStuckRef.current = true
 
-    const el = textareaRef.current
+    const el = (shouldUseCodeRenderer ? codeScrollRef.current : textareaRef.current) ?? null
     if (!el) return
 
-    const onWheel = (e: WheelEvent) => {
-      if (e.deltaY < 0) textareaStuckRef.current = false
+    const onWheel = (e: Event) => {
+      if ((e as WheelEvent).deltaY < 0) textareaStuckRef.current = false
     }
 
     const onScroll = () => {
@@ -367,14 +920,20 @@ function TextEditor({
       el.removeEventListener('wheel', onWheel)
       el.removeEventListener('scroll', onScroll)
     }
-  }, [isStreaming])
+  }, [disableStreamingAutoScroll, isStreaming, shouldUseCodeRenderer])
 
   useEffect(() => {
-    if (!isStreaming || !textareaStuckRef.current) return
-    const el = textareaRef.current
+    if (!isStreaming || !textareaStuckRef.current || disableStreamingAutoScroll) return
+    const el = (shouldUseCodeRenderer ? codeScrollRef.current : textareaRef.current) ?? null
     if (!el) return
     el.scrollTop = el.scrollHeight
-  }, [isStreaming, revealedContent])
+  }, [disableStreamingAutoScroll, isStreaming, renderedContent, shouldUseCodeRenderer])
+
+  const previewType = resolvePreviewType(file.type, file.name)
+  const isIframeRendered = previewType === 'html' || previewType === 'svg'
+  const effectiveMode = isStreaming && isIframeRendered ? 'editor' : previewMode
+  const showEditor = effectiveMode !== 'preview'
+  const showPreviewPane = effectiveMode !== 'editor'
 
   if (streamingContent === undefined) {
     if (isLoading) return DOCUMENT_SKELETON
@@ -388,29 +947,56 @@ function TextEditor({
     }
   }
 
-  const previewType = resolvePreviewType(file.type, file.name)
-  const isIframeRendered = previewType === 'html' || previewType === 'svg'
-  const effectiveMode = isStreaming && isIframeRendered ? 'editor' : previewMode
-  const showEditor = effectiveMode !== 'preview'
-  const showPreviewPane = effectiveMode !== 'editor'
-
   return (
     <div ref={containerRef} className='relative flex flex-1 overflow-hidden'>
-      {showEditor && (
-        <textarea
-          ref={textareaRef}
-          value={isStreaming ? revealedContent : content}
-          onChange={(e) => handleContentChange(e.target.value)}
-          readOnly={!canEdit}
-          spellCheck={false}
-          style={showPreviewPane ? { width: `${splitPct}%`, flexShrink: 0 } : undefined}
-          className={cn(
-            'h-full resize-none border-0 bg-transparent p-[24px] font-mono text-[14px] text-[var(--text-body)] outline-none placeholder:text-[var(--text-subtle)]',
-            !showPreviewPane && 'w-full',
-            isResizing && 'pointer-events-none'
-          )}
-        />
-      )}
+      {showEditor &&
+        (shouldUseCodeRenderer ? (
+          <div
+            style={showPreviewPane ? { width: `${splitPct}%`, flexShrink: 0 } : undefined}
+            className={cn(
+              'min-w-0',
+              !showPreviewPane && 'w-full',
+              isResizing && 'pointer-events-none'
+            )}
+          >
+            <div ref={codeScrollRef} className='h-full overflow-auto'>
+              <CodeEditor.Container className='min-h-full min-w-full overflow-visible rounded-none border-0 bg-transparent'>
+                <CodeEditor.Gutter width={gutterWidthPx}>
+                  {renderCodeLineNumbers()}
+                </CodeEditor.Gutter>
+                <CodeEditor.Content paddingLeft={`${gutterWidthPx}px`} editorRef={codeEditorRef}>
+                  <Editor
+                    value={renderedContent}
+                    onValueChange={handleCodeContentChange}
+                    highlight={highlightCode}
+                    padding={sharedCodeEditorProps.padding}
+                    readOnly={isEditorReadOnly}
+                    className={cn(
+                      sharedCodeEditorProps.className,
+                      'min-h-full',
+                      isEditorReadOnly && 'opacity-100'
+                    )}
+                    textareaClassName={cn(sharedCodeEditorProps.textareaClassName, 'min-h-full')}
+                  />
+                </CodeEditor.Content>
+              </CodeEditor.Container>
+            </div>
+          </div>
+        ) : (
+          <textarea
+            ref={textareaRef}
+            value={renderedContent}
+            onChange={(e) => handleContentChange(e.target.value)}
+            readOnly={isEditorReadOnly}
+            spellCheck={false}
+            style={showPreviewPane ? { width: `${splitPct}%`, flexShrink: 0 } : undefined}
+            className={cn(
+              'h-full resize-none border-0 bg-transparent p-[24px] font-mono text-[14px] text-[var(--text-body)] outline-none placeholder:text-[var(--text-subtle)]',
+              !showPreviewPane && 'w-full',
+              isResizing && 'pointer-events-none'
+            )}
+          />
+        ))}
       {showPreviewPane && (
         <>
           {showEditor && (
@@ -432,7 +1018,8 @@ function TextEditor({
             className={cn('min-w-0 flex-1 overflow-hidden', isResizing && 'pointer-events-none')}
           >
             <PreviewPanel
-              content={isStreaming ? revealedContent : content}
+              key={previewContextKey ? `${file.id}:${previewContextKey}` : file.id}
+              content={renderedContent}
               mimeType={file.type}
               filename={file.name}
               isStreaming={isStreaming}
@@ -445,13 +1032,141 @@ function TextEditor({
   )
 }
 
-const IframePreview = memo(function IframePreview({ file }: { file: WorkspaceFileRecord }) {
-  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace`
+const IframePreview = memo(function IframePreview({
+  file,
+  workspaceId,
+  streamingContent,
+}: {
+  file: WorkspaceFileRecord
+  workspaceId: string
+  streamingContent?: string
+}) {
+  const {
+    data: fileData,
+    isLoading,
+    error: fetchError,
+  } = useWorkspaceFileBinary(workspaceId, file.id, file.key)
+  const [blobUrl, setBlobUrl] = useState<string | null>(null)
+  const blobUrlRef = useRef<string | null>(null)
+  const [rendering, setRendering] = useState(false)
+  const [renderError, setRenderError] = useState<string | null>(null)
+
+  const replaceBlobUrl = useCallback((nextUrl: string | null) => {
+    const previousUrl = blobUrlRef.current
+    blobUrlRef.current = nextUrl
+    setBlobUrl(nextUrl)
+    if (previousUrl && previousUrl !== nextUrl) {
+      URL.revokeObjectURL(previousUrl)
+    }
+  }, [])
+
+  useEffect(() => {
+    replaceBlobUrl(null)
+    setRenderError(null)
+    setRendering(false)
+  }, [file.id, file.key, replaceBlobUrl])
+
+  useEffect(() => {
+    return () => {
+      if (blobUrlRef.current) {
+        URL.revokeObjectURL(blobUrlRef.current)
+        blobUrlRef.current = null
+      }
+    }
+  }, [])
+
+  useEffect(() => {
+    if (streamingContent !== undefined || !fileData) return
+    setRenderError(null)
+    replaceBlobUrl(URL.createObjectURL(new Blob([fileData], { type: 'application/pdf' })))
+  }, [fileData, streamingContent, replaceBlobUrl])
+
+  useEffect(() => {
+    if (streamingContent === undefined) return
+
+    let cancelled = false
+    const controller = new AbortController()
+
+    const debounceTimer = setTimeout(async () => {
+      if (cancelled) return
+
+      try {
+        setRendering(true)
+        setRenderError(null)
+
+        const response = await fetch(`/api/workspaces/${workspaceId}/pdf/preview`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ code: streamingContent }),
+          signal: controller.signal,
+        })
+        if (!response.ok) {
+          const err = await response.json().catch(() => ({ error: 'Preview failed' }))
+          throw new Error(err.error || 'Preview failed')
+        }
+
+        const arrayBuffer = await response.arrayBuffer()
+        if (cancelled) return
+
+        const nextBlobUrl = URL.createObjectURL(
+          new Blob([arrayBuffer], { type: 'application/pdf' })
+        )
+        if (cancelled) {
+          URL.revokeObjectURL(nextBlobUrl)
+          return
+        }
+
+        replaceBlobUrl(nextBlobUrl)
+      } catch (err) {
+        if (!cancelled && !(err instanceof DOMException && err.name === 'AbortError')) {
+          const msg = err instanceof Error ? err.message : 'Failed to render PDF'
+          if (blobUrlRef.current || shouldSuppressStreamingDocumentError(msg)) {
+            logger.info('Suppressing transient PDF streaming preview error', { error: msg })
+          } else {
+            logger.error('PDF render failed', { error: msg })
+            setRenderError(msg)
+          }
+        }
+      } finally {
+        if (!cancelled) {
+          setRendering(false)
+        }
+      }
+    }, 500)
+
+    return () => {
+      cancelled = true
+      clearTimeout(debounceTimer)
+      controller.abort()
+    }
+  }, [streamingContent, workspaceId, replaceBlobUrl])
+
+  const error =
+    blobUrl !== null
+      ? null
+      : streamingContent !== undefined
+        ? renderError
+        : resolvePreviewError(fetchError, renderError)
+
+  if (error) {
+    return <PreviewError label='PDF' error={error} />
+  }
+
+  if (
+    (streamingContent !== undefined && !blobUrl) ||
+    (streamingContent === undefined && (isLoading || rendering) && !blobUrl)
+  ) {
+    return (
+      <div className='flex h-full items-center justify-center'>
+        <Skeleton className='h-[200px] w-[80%]' />
+      </div>
+    )
+  }
 
   return (
     <div className='flex flex-1 overflow-hidden'>
       <iframe
-        src={serveUrl}
+        src={blobUrl ?? undefined}
         className='h-full w-full border-0'
         title={file.name}
         onError={() => {
@@ -469,8 +1184,20 @@ const ZOOM_BUTTON_FACTOR = 1.2
 
 const clampZoom = (z: number) => Math.min(Math.max(z, ZOOM_MIN), ZOOM_MAX)
 
-const ImagePreview = memo(function ImagePreview({ file }: { file: WorkspaceFileRecord }) {
-  const serveUrl = `/api/files/serve/${encodeURIComponent(file.key)}?context=workspace`
+const ImagePreview = memo(function ImagePreview({
+  file,
+  workspaceId,
+}: {
+  file: WorkspaceFileRecord
+  workspaceId: string
+}) {
+  const {
+    data: fileData,
+    isLoading,
+    error: fetchError,
+  } = useWorkspaceFileBinary(workspaceId, file.id, file.key)
+  const [blobUrl, setBlobUrl] = useState<string | null>(null)
+  const blobUrlRef = useRef<string | null>(null)
   const [zoom, setZoom] = useState(1)
   const [offset, setOffset] = useState({ x: 0, y: 0 })
   const isDragging = useRef(false)
@@ -481,6 +1208,15 @@ const ImagePreview = memo(function ImagePreview({ file }: { file: WorkspaceFileR
 
   const containerRef = useRef<HTMLDivElement>(null)
 
+  const replaceBlobUrl = useCallback((nextUrl: string | null) => {
+    const previousUrl = blobUrlRef.current
+    blobUrlRef.current = nextUrl
+    setBlobUrl(nextUrl)
+    if (previousUrl && previousUrl !== nextUrl) {
+      URL.revokeObjectURL(previousUrl)
+    }
+  }, [])
+
   const zoomIn = useCallback(() => setZoom((z) => clampZoom(z * ZOOM_BUTTON_FACTOR)), [])
   const zoomOut = useCallback(() => setZoom((z) => clampZoom(z / ZOOM_BUTTON_FACTOR)), [])
 
@@ -499,6 +1235,24 @@ const ImagePreview = memo(function ImagePreview({ file }: { file: WorkspaceFileR
     return () => el.removeEventListener('wheel', onWheel)
   }, [])
 
+  useEffect(() => {
+    replaceBlobUrl(null)
+  }, [file.id, file.key, replaceBlobUrl])
+
+  useEffect(() => {
+    return () => {
+      if (blobUrlRef.current) {
+        URL.revokeObjectURL(blobUrlRef.current)
+        blobUrlRef.current = null
+      }
+    }
+  }, [])
+
+  useEffect(() => {
+    if (!fileData) return
+    replaceBlobUrl(URL.createObjectURL(new Blob([fileData], { type: file.type || 'image/png' })))
+  }, [file.type, fileData, replaceBlobUrl])
+
   const handleMouseDown = useCallback((e: React.MouseEvent) => {
     if (e.button !== 0) return
     isDragging.current = true
@@ -524,7 +1278,21 @@ const ImagePreview = memo(function ImagePreview({ file }: { file: WorkspaceFileR
   useEffect(() => {
     setZoom(1)
     setOffset({ x: 0, y: 0 })
-  }, [file.key])
+  }, [blobUrl])
+
+  const error = blobUrl !== null ? null : resolvePreviewError(fetchError, null)
+
+  if (error) {
+    return <PreviewError label='Image' error={error} />
+  }
+
+  if (isLoading && !blobUrl) {
+    return (
+      <div className='flex h-full items-center justify-center'>
+        <Skeleton className='h-[200px] w-[80%]' />
+      </div>
+    )
+  }
 
   return (
     <div
@@ -543,7 +1311,7 @@ const ImagePreview = memo(function ImagePreview({ file }: { file: WorkspaceFileR
         }}
       >
         <img
-          src={serveUrl}
+          src={blobUrl ?? undefined}
           alt={file.name}
           className='max-h-full max-w-full select-none rounded-md object-contain'
           draggable={false}
@@ -585,6 +1353,20 @@ function resolvePreviewError(fetchError: Error | null, renderError: string | nul
   return renderError
 }
 
+function shouldSuppressStreamingDocumentError(message: string): boolean {
+  const lower = message.toLowerCase()
+  return (
+    lower.includes('preview failed') ||
+    lower.includes('aborterror') ||
+    lower.includes('unexpected end') ||
+    lower.includes('unexpected eof') ||
+    lower.includes('invalid or unexpected token') ||
+    lower.includes('end of central directory') ||
+    lower.includes('corrupted zip') ||
+    lower.includes('end of data reached')
+  )
+}
+
 function PreviewError({ label, error }: { label: string; error: string }) {
   return (
     <div className='flex flex-1 flex-col items-center justify-center gap-[8px]'>
@@ -603,6 +1385,170 @@ const DOCUMENT_SKELETON = (
   </div>
 )
 
+const DocxPreview = memo(function DocxPreview({
+  file,
+  workspaceId,
+  streamingContent,
+}: {
+  file: WorkspaceFileRecord
+  workspaceId: string
+  streamingContent?: string
+}) {
+  const containerRef = useRef<HTMLDivElement>(null)
+  const lastSuccessfulHtmlRef = useRef('')
+  const {
+    data: fileData,
+    isLoading,
+    error: fetchError,
+  } = useWorkspaceFileBinary(workspaceId, file.id, file.key)
+  const [renderError, setRenderError] = useState<string | null>(null)
+  const [rendering, setRendering] = useState(false)
+  const [hasRenderedPreview, setHasRenderedPreview] = useState(false)
+
+  useEffect(() => {
+    lastSuccessfulHtmlRef.current = ''
+    setRenderError(null)
+    setRendering(false)
+    setHasRenderedPreview(false)
+    if (containerRef.current) {
+      containerRef.current.innerHTML = ''
+    }
+  }, [file.id, file.key])
+
+  useEffect(() => {
+    if (!containerRef.current || !fileData || streamingContent !== undefined) return
+
+    let cancelled = false
+
+    async function render() {
+      try {
+        setRendering(true)
+        const { renderAsync } = await import('docx-preview')
+        if (cancelled || !containerRef.current) return
+        setRenderError(null)
+        containerRef.current.innerHTML = ''
+        await renderAsync(fileData, containerRef.current, undefined, {
+          inWrapper: true,
+          ignoreWidth: false,
+          ignoreHeight: false,
+        })
+        if (!cancelled && containerRef.current) {
+          lastSuccessfulHtmlRef.current = containerRef.current.innerHTML
+          setHasRenderedPreview(true)
+        }
+      } catch (err) {
+        if (!cancelled) {
+          const msg = err instanceof Error ? err.message : 'Failed to render document'
+          logger.error('DOCX render failed', { error: msg })
+          setRenderError(msg)
+        }
+      } finally {
+        if (!cancelled) {
+          setRendering(false)
+        }
+      }
+    }
+
+    render()
+    return () => {
+      cancelled = true
+    }
+  }, [fileData, streamingContent])
+
+  useEffect(() => {
+    if (streamingContent === undefined || !containerRef.current) return
+
+    let cancelled = false
+    const controller = new AbortController()
+
+    const debounceTimer = setTimeout(async () => {
+      const container = containerRef.current
+      if (!container || cancelled) return
+
+      const previousHtml = lastSuccessfulHtmlRef.current
+
+      try {
+        setRendering(true)
+        setRenderError(null)
+
+        const response = await fetch(`/api/workspaces/${workspaceId}/docx/preview`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ code: streamingContent }),
+          signal: controller.signal,
+        })
+        if (!response.ok) {
+          const err = await response.json().catch(() => ({ error: 'Preview failed' }))
+          throw new Error(err.error || 'Preview failed')
+        }
+
+        const arrayBuffer = await response.arrayBuffer()
+        if (cancelled || !containerRef.current) return
+
+        const { renderAsync } = await import('docx-preview')
+        if (cancelled || !containerRef.current) return
+
+        containerRef.current.innerHTML = ''
+        await renderAsync(new Uint8Array(arrayBuffer), containerRef.current, undefined, {
+          inWrapper: true,
+          ignoreWidth: false,
+          ignoreHeight: false,
+        })
+
+        if (!cancelled && containerRef.current) {
+          lastSuccessfulHtmlRef.current = containerRef.current.innerHTML
+          setHasRenderedPreview(true)
+        }
+      } catch (err) {
+        if (!cancelled && !(err instanceof DOMException && err.name === 'AbortError')) {
+          if (containerRef.current && previousHtml) {
+            containerRef.current.innerHTML = previousHtml
+            setHasRenderedPreview(true)
+          }
+          const msg = err instanceof Error ? err.message : 'Failed to render document'
+          if (previousHtml || shouldSuppressStreamingDocumentError(msg)) {
+            logger.info('Suppressing transient DOCX streaming preview error', { error: msg })
+          } else {
+            logger.error('DOCX render failed', { error: msg })
+            setRenderError(msg)
+          }
+        }
+      } finally {
+        if (!cancelled) {
+          setRendering(false)
+        }
+      }
+    }, 500)
+
+    return () => {
+      cancelled = true
+      clearTimeout(debounceTimer)
+      controller.abort()
+    }
+  }, [streamingContent, workspaceId])
+
+  const error =
+    hasRenderedPreview && streamingContent !== undefined
+      ? null
+      : streamingContent !== undefined
+        ? renderError
+        : resolvePreviewError(fetchError, renderError)
+  if (error) return <PreviewError label='document' error={error} />
+  const showSkeleton =
+    !hasRenderedPreview &&
+    ((streamingContent !== undefined && rendering) || (streamingContent === undefined && isLoading))
+
+  return (
+    <div className='relative h-full w-full overflow-auto bg-white'>
+      {showSkeleton && <div className='absolute inset-0 z-10 bg-white'>{DOCUMENT_SKELETON}</div>}
+      <div
+        ref={containerRef}
+        className={cn('h-full w-full overflow-auto bg-white', showSkeleton && 'opacity-0')}
+      />
+    </div>
+  )
+})
+
 const pptxSlideCache = new Map<string, string[]>()
 
 function pptxCacheKey(fileId: string, dataUpdatedAt: number, byteLength: number): string {
@@ -715,6 +1661,15 @@ function PptxPreview({
   const [rendering, setRendering] = useState(false)
   const [renderError, setRenderError] = useState<string | null>(null)
 
+  const shouldSuppressStreamingPptxError = (message: string): boolean => {
+    return (
+      shouldSuppressStreamingDocumentError(message) ||
+      message.includes('SyntaxError: Invalid or unexpected token') ||
+      message.includes('PPTX generation cancelled') ||
+      message.includes('SyntaxError: Unexpected end of input')
+    )
+  }
+
   // Streaming preview: only re-triggers when the streaming source code or
   // workspace changes. Isolated from fileData/dataUpdatedAt so that file-list
   // refreshes don't abort the in-flight compilation request.
@@ -756,8 +1711,12 @@ function PptxPreview({
       } catch (err) {
         if (!cancelled && !(err instanceof DOMException && err.name === 'AbortError')) {
           const msg = err instanceof Error ? err.message : 'Failed to render presentation'
-          logger.error('PPTX render failed', { error: msg })
-          setRenderError(msg)
+          if (shouldSuppressStreamingPptxError(msg)) {
+            logger.info('Suppressing transient PPTX streaming preview error', { error: msg })
+          } else {
+            logger.error('PPTX render failed', { error: msg })
+            setRenderError(msg)
+          }
         }
       } finally {
         if (!cancelled) setRendering(false)
@@ -865,77 +1824,6 @@ function toggleMarkdownCheckbox(markdown: string, targetIndex: number, checked:
   })
 }
 
-const DocxPreview = memo(function DocxPreview({
-  file,
-  workspaceId,
-}: {
-  file: WorkspaceFileRecord
-  workspaceId: string
-}) {
-  const {
-    data: fileData,
-    isLoading,
-    error: fetchError,
-  } = useWorkspaceFileBinary(workspaceId, file.id, file.key)
-
-  const [html, setHtml] = useState<string | null>(null)
-  const [renderError, setRenderError] = useState<string | null>(null)
-
-  useEffect(() => {
-    if (!fileData) return
-    const data = fileData
-
-    let cancelled = false
-
-    async function convert() {
-      try {
-        setRenderError(null)
-        const mammoth = await import('mammoth')
-        const result = await mammoth.convertToHtml({ arrayBuffer: data })
-        if (!cancelled) setHtml(result.value)
-      } catch (err) {
-        if (!cancelled) {
-          const msg = err instanceof Error ? err.message : 'Failed to render document'
-          logger.error('DOCX render failed', { error: msg })
-          setRenderError(msg)
-        }
-      }
-    }
-
-    convert()
-    return () => {
-      cancelled = true
-    }
-  }, [fileData])
-
-  const error = resolvePreviewError(fetchError, renderError)
-  if (error) return <PreviewError label='document' error={error} />
-  if (isLoading || html === null) return DOCUMENT_SKELETON
-
-  return (
-    <div className='flex flex-1 overflow-hidden'>
-      <iframe
-        srcDoc={buildDocxPreviewHtml(html)}
-        sandbox=''
-        title={file.name}
-        className='h-full w-full border-0'
-      />
-    </div>
-  )
-})
-
-/** Wraps mammoth HTML output with base styles. Uses raw hex colors because iframes cannot inherit CSS variables from the parent document. */
-function buildDocxPreviewHtml(html: string): string {
-  return `<!DOCTYPE html><html><head><style>
-body { margin: 0; padding: 24px; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; font-size: 14px; line-height: 1.6; color: #e4e4e7; background: transparent; }
-table { border-collapse: collapse; width: 100%; margin: 12px 0; }
-td, th { border: 1px solid #3f3f46; padding: 6px 10px; }
-img { max-width: 100%; height: auto; }
-p { margin: 0 0 8px; }
-h1, h2, h3, h4, h5, h6 { margin: 16px 0 8px; }
-</style></head><body>${html}</body></html>`
-}
-
 const XLSX_MAX_ROWS = 1_000
 
 interface XlsxSheet {
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
index 2e77eae3eb4..01d2c6e1f29 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
@@ -1,19 +1,31 @@
 'use client'
 
-import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef } from 'react'
+import {
+  createContext,
+  memo,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react'
 import { useRouter } from 'next/navigation'
-import type { Components, ExtraProps } from 'react-markdown'
-import ReactMarkdown from 'react-markdown'
 import rehypeSlug from 'rehype-slug'
 import remarkBreaks from 'remark-breaks'
 import remarkGfm from 'remark-gfm'
+import { Streamdown } from 'streamdown'
+import 'streamdown/styles.css'
 import { Checkbox } from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import { getFileExtension } from '@/lib/uploads/utils/file-utils'
 import { useAutoScroll } from '@/hooks/use-auto-scroll'
-import { useStreamingReveal } from '@/hooks/use-streaming-reveal'
 import { DataTable } from './data-table'
 
+interface HastNode {
+  position?: { start?: { offset?: number } }
+}
+
 type PreviewType = 'markdown' | 'html' | 'csv' | 'svg' | null
 
 const PREVIEWABLE_MIME_TYPES: Record<string, PreviewType> = {
@@ -127,30 +139,16 @@ const STATIC_MARKDOWN_COMPONENTS = {
       {children}
     </h4>
   ),
-  code: ({
-    className,
-    children,
-    node: _node,
-    ...props
-  }: React.HTMLAttributes<HTMLElement> & ExtraProps) => {
-    const isInline = !className?.includes('language-')
-
-    if (isInline) {
+  inlineCode: ({ children }: { children?: React.ReactNode }) => {
+    if (typeof children === 'string' && children.includes('\n')) {
       return (
-        <code
-          {...props}
-          className='whitespace-normal rounded bg-[var(--surface-5)] px-1.5 py-0.5 font-mono text-[13px] text-[var(--caution)]'
-        >
+        <code className='my-4 block overflow-x-auto whitespace-pre-wrap break-words rounded-lg bg-[var(--surface-5)] p-4 font-mono text-[13px] text-[var(--text-primary)] leading-[1.6]'>
           {children}
         </code>
       )
     }
-
     return (
-      <code
-        {...props}
-        className='my-3 block whitespace-pre-wrap break-words rounded-md bg-[var(--surface-5)] p-4 font-mono text-[13px] text-[var(--text-primary)]'
-      >
+      <code className='whitespace-normal rounded bg-[var(--surface-5)] px-1.5 py-0.5 font-mono text-[13px] text-[var(--caution)]'>
         {children}
       </code>
     )
@@ -168,8 +166,13 @@ const STATIC_MARKDOWN_COMPONENTS = {
     </blockquote>
   ),
   hr: () => <hr className='my-6 border-[var(--border)]' />,
-  img: ({ src, alt, node: _node }: React.ComponentPropsWithoutRef<'img'> & ExtraProps) => (
-    <img src={src} alt={alt ?? ''} className='my-3 max-w-full rounded-md' loading='lazy' />
+  img: ({ src, alt }: React.ImgHTMLAttributes<HTMLImageElement>) => (
+    <img
+      src={src as string}
+      alt={alt ?? ''}
+      className='my-3 max-w-full rounded-md'
+      loading='lazy'
+    />
   ),
   table: ({ children }: { children?: React.ReactNode }) => (
     <div className='my-4 max-w-full overflow-x-auto'>
@@ -193,7 +196,7 @@ const STATIC_MARKDOWN_COMPONENTS = {
   ),
 }
 
-function UlRenderer({ className, children }: React.ComponentPropsWithoutRef<'ul'> & ExtraProps) {
+function UlRenderer({ className, children }: { className?: string; children?: React.ReactNode }) {
   const isTaskList = typeof className === 'string' && className.includes('contains-task-list')
   return (
     <ul
@@ -207,7 +210,7 @@ function UlRenderer({ className, children }: React.ComponentPropsWithoutRef<'ul'
   )
 }
 
-function OlRenderer({ className, children }: React.ComponentPropsWithoutRef<'ol'> & ExtraProps) {
+function OlRenderer({ className, children }: { className?: string; children?: React.ReactNode }) {
   const isTaskList = typeof className === 'string' && className.includes('contains-task-list')
   return (
     <ol
@@ -225,7 +228,11 @@ function LiRenderer({
   className,
   children,
   node,
-}: React.ComponentPropsWithoutRef<'li'> & ExtraProps) {
+}: {
+  className?: string
+  children?: React.ReactNode
+  node?: HastNode
+}) {
   const ctx = useContext(MarkdownCheckboxCtx)
   const isTaskItem = typeof className === 'string' && className.includes('task-list-item')
 
@@ -249,12 +256,7 @@ function LiRenderer({
   return <li className='break-words leading-[1.6]'>{children}</li>
 }
 
-function InputRenderer({
-  type,
-  checked,
-  node: _node,
-  ...props
-}: React.ComponentPropsWithoutRef<'input'> & ExtraProps) {
+function InputRenderer({ type, checked, ...props }: React.ComponentPropsWithoutRef<'input'>) {
   const ctx = useContext(MarkdownCheckboxCtx)
   const index = useContext(CheckboxIndexCtx)
 
@@ -348,7 +350,7 @@ const MARKDOWN_COMPONENTS = {
   ol: OlRenderer,
   li: LiRenderer,
   input: InputRenderer,
-} satisfies Components
+}
 
 const MarkdownPreview = memo(function MarkdownPreview({
   content,
@@ -360,8 +362,8 @@ const MarkdownPreview = memo(function MarkdownPreview({
   onCheckboxToggle?: (checkboxIndex: number, checked: boolean) => void
 }) {
   const { push: navigate } = useRouter()
-  const { ref: scrollRef } = useAutoScroll(isStreaming)
-  const { committed, incoming, generation } = useStreamingReveal(content, isStreaming)
+  const { ref: autoScrollRef } = useAutoScroll(isStreaming)
+  const scrollContainerRef = useRef<HTMLDivElement>(null)
 
   const contentRef = useRef(content)
   contentRef.current = content
@@ -370,6 +372,13 @@ const MarkdownPreview = memo(function MarkdownPreview({
     () => (onCheckboxToggle ? { contentRef, onToggle: onCheckboxToggle } : null),
     [onCheckboxToggle]
   )
+  const setScrollRef = useCallback(
+    (node: HTMLDivElement | null) => {
+      scrollContainerRef.current = node
+      autoScrollRef(node)
+    },
+    [autoScrollRef]
+  )
 
   const hasScrolledToHash = useRef(false)
   useEffect(() => {
@@ -387,32 +396,21 @@ const MarkdownPreview = memo(function MarkdownPreview({
     }
   }, [content])
 
-  const committedMarkdown = useMemo(
-    () =>
-      committed ? (
-        <ReactMarkdown
-          remarkPlugins={REMARK_PLUGINS}
-          rehypePlugins={REHYPE_PLUGINS}
-          components={MARKDOWN_COMPONENTS}
-        >
-          {committed}
-        </ReactMarkdown>
-      ) : null,
-    [committed]
-  )
+  const streamdownMode = isStreaming ? undefined : 'static'
 
   if (onCheckboxToggle) {
     return (
       <NavigateCtx.Provider value={navigate}>
         <MarkdownCheckboxCtx.Provider value={ctxValue}>
-          <div ref={scrollRef} className='h-full overflow-auto p-6'>
-            <ReactMarkdown
+          <div ref={setScrollRef} className='h-full overflow-auto p-6'>
+            <Streamdown
+              mode={streamdownMode}
               remarkPlugins={REMARK_PLUGINS}
               rehypePlugins={REHYPE_PLUGINS}
               components={MARKDOWN_COMPONENTS}
             >
               {content}
-            </ReactMarkdown>
+            </Streamdown>
           </div>
         </MarkdownCheckboxCtx.Provider>
       </NavigateCtx.Provider>
@@ -421,36 +419,153 @@ const MarkdownPreview = memo(function MarkdownPreview({
 
   return (
     <NavigateCtx.Provider value={navigate}>
-      <div ref={scrollRef} className='h-full overflow-auto p-6'>
-        {committedMarkdown}
-        {incoming && (
-          <div
-            key={generation}
-            className={cn(isStreaming && 'animate-stream-fade-in', '[&>:first-child]:mt-0')}
-          >
-            <ReactMarkdown
-              remarkPlugins={REMARK_PLUGINS}
-              rehypePlugins={REHYPE_PLUGINS}
-              components={MARKDOWN_COMPONENTS}
-            >
-              {incoming}
-            </ReactMarkdown>
-          </div>
-        )}
+      <div ref={setScrollRef} className='h-full overflow-auto p-6'>
+        <Streamdown
+          mode={streamdownMode}
+          remarkPlugins={REMARK_PLUGINS}
+          rehypePlugins={REHYPE_PLUGINS}
+          components={MARKDOWN_COMPONENTS}
+        >
+          {content}
+        </Streamdown>
       </div>
     </NavigateCtx.Provider>
   )
 })
 
+const HTML_PREVIEW_BASE_URL = 'about:srcdoc'
+
+const HTML_PREVIEW_CSP = [
+  "default-src 'none'",
+  "script-src 'unsafe-inline'",
+  "style-src 'unsafe-inline'",
+  'img-src data: blob:',
+  'font-src data:',
+  'media-src data: blob:',
+  "connect-src 'none'",
+  "form-action 'none'",
+  "frame-src 'none'",
+  "child-src 'none'",
+  "object-src 'none'",
+].join('; ')
+
+const HTML_PREVIEW_BOOTSTRAP = `<script>
+(() => {
+  const allowHref = (href) => href.startsWith('#') || /^\\s*javascript:/i.test(href)
+
+  document.addEventListener(
+    'click',
+    (event) => {
+      if (!(event.target instanceof Element)) return
+      const anchor = event.target.closest('a[href]')
+      if (!(anchor instanceof HTMLAnchorElement)) return
+      const href = anchor.getAttribute('href') || ''
+      if (allowHref(href)) return
+      event.preventDefault()
+    },
+    true
+  )
+
+  document.addEventListener(
+    'submit',
+    (event) => {
+      event.preventDefault()
+    },
+    true
+  )
+
+})()
+</script>`
+
+function buildHtmlPreviewDocument(content: string): string {
+  const headInjection = [
+    '<meta charset="utf-8">',
+    `<base href="${HTML_PREVIEW_BASE_URL}">`,
+    `<meta http-equiv="Content-Security-Policy" content="${HTML_PREVIEW_CSP}">`,
+    HTML_PREVIEW_BOOTSTRAP,
+  ].join('')
+
+  if (/<head[\s>]/i.test(content)) {
+    return content.replace(/<head(\s[^>]*)?>/i, (match) => `${match}${headInjection}`)
+  }
+
+  if (/<html[\s>]/i.test(content)) {
+    return content.replace(/<html(\s[^>]*)?>/i, (match) => `${match}<head>${headInjection}</head>`)
+  }
+
+  return `<!DOCTYPE html><html><head>${headInjection}</head><body>${content}</body></html>`
+}
+
 const HtmlPreview = memo(function HtmlPreview({ content }: { content: string }) {
+  // Run inline HTML/JS in an isolated iframe while blocking any navigation
+  // that would replace the preview with another document.
+  const wrappedContent = useMemo(() => buildHtmlPreviewDocument(content), [content])
+  const containerRef = useRef<HTMLDivElement>(null)
+  const [isRenderable, setIsRenderable] = useState(false)
+  const [resumeNonce, setResumeNonce] = useState(0)
+  const pageWasHiddenRef = useRef(false)
+
+  useEffect(() => {
+    const container = containerRef.current
+    if (!container) return
+
+    const updateRenderability = (width: number, height: number) => {
+      setIsRenderable(width > 0 && height > 0)
+    }
+
+    const initialRect = container.getBoundingClientRect()
+    updateRenderability(initialRect.width, initialRect.height)
+
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0]
+      if (!entry) return
+      updateRenderability(entry.contentRect.width, entry.contentRect.height)
+    })
+    observer.observe(container)
+
+    return () => observer.disconnect()
+  }, [])
+
+  useEffect(() => {
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === 'hidden') {
+        pageWasHiddenRef.current = true
+        return
+      }
+
+      if (document.visibilityState === 'visible' && pageWasHiddenRef.current) {
+        pageWasHiddenRef.current = false
+        setResumeNonce((nonce) => nonce + 1)
+      }
+    }
+
+    const handlePageShow = (event: PageTransitionEvent) => {
+      if (event.persisted) {
+        setResumeNonce((nonce) => nonce + 1)
+      }
+    }
+
+    document.addEventListener('visibilitychange', handleVisibilityChange)
+    window.addEventListener('pageshow', handlePageShow)
+
+    return () => {
+      document.removeEventListener('visibilitychange', handleVisibilityChange)
+      window.removeEventListener('pageshow', handlePageShow)
+    }
+  }, [])
+
   return (
-    <div className='h-full overflow-hidden'>
-      <iframe
-        srcDoc={content}
-        sandbox='allow-same-origin'
-        title='HTML Preview'
-        className='h-full w-full border-0 bg-white'
-      />
+    <div ref={containerRef} className='h-full overflow-hidden'>
+      {isRenderable && (
+        <iframe
+          key={resumeNonce}
+          srcDoc={wrappedContent}
+          sandbox='allow-scripts'
+          referrerPolicy='no-referrer'
+          title='HTML Preview'
+          className='h-full w-full border-0 bg-white'
+        />
+      )}
     </div>
   )
 })
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
index 41a0011a81d..9de719a7f13 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
@@ -111,6 +111,7 @@ export function AgentGroup({
                     toolName={item.data.toolName}
                     displayTitle={item.data.displayTitle}
                     status={item.data.status}
+                    streamingArgs={item.data.streamingArgs}
                   />
                 ) : (
                   <span
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
index 05a91c3a364..e28f4f51d4f 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
@@ -1,4 +1,6 @@
+import { useMemo } from 'react'
 import { PillsRing } from '@/components/emcn'
+import { FunctionExecute, WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { ToolCallStatus } from '../../../../types'
 import { getToolIcon } from '../../utils'
 
@@ -54,19 +56,95 @@ function StatusIcon({ status, toolName }: { status: ToolCallStatus; toolName: st
   return <CircleCheck className='h-[15px] w-[15px] text-[var(--text-tertiary)]' />
 }
 
+const LANG_ALIASES: Record<string, string> = {
+  javascript: 'javascript',
+  python: 'python',
+  shell: 'bash',
+  bash: 'bash',
+}
+
+function extractFunctionExecutePreview(raw: string): { code: string; lang: string } | null {
+  if (!raw) return null
+  const langMatch = raw.match(/"language"\s*:\s*"(\w+)"/)
+  const lang = langMatch ? (LANG_ALIASES[langMatch[1]] ?? langMatch[1]) : 'javascript'
+
+  const codeStart = raw.indexOf('"code"')
+  if (codeStart === -1) return null
+  const colonIdx = raw.indexOf(':', codeStart + 6)
+  if (colonIdx === -1) return null
+  const quoteIdx = raw.indexOf('"', colonIdx + 1)
+  if (quoteIdx === -1) return null
+
+  let value = raw.slice(quoteIdx + 1)
+  if (value.endsWith('"}') || value.endsWith('"\n}')) {
+    value = value.replace(/"\s*\}?\s*$/, '')
+  }
+  if (value.endsWith('"')) {
+    value = value.slice(0, -1)
+  }
+
+  const code = value
+    .replace(/\\n/g, '\n')
+    .replace(/\\t/g, '\t')
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\')
+
+  return code.length > 0 ? { code, lang } : null
+}
+
 interface ToolCallItemProps {
   toolName: string
   displayTitle: string
   status: ToolCallStatus
+  streamingArgs?: string
 }
 
-export function ToolCallItem({ toolName, displayTitle, status }: ToolCallItemProps) {
+export function ToolCallItem({ toolName, displayTitle, status, streamingArgs }: ToolCallItemProps) {
+  const liveWorkspaceFileTitle = useMemo(() => {
+    if (toolName !== WorkspaceFile.id || !streamingArgs) return null
+    const titleMatch = streamingArgs.match(/"title"\s*:\s*"([^"]+)"/)
+    if (!titleMatch?.[1]) return null
+    const opMatch = streamingArgs.match(/"operation"\s*:\s*"(\w+)"/)
+    const op = opMatch?.[1] ?? ''
+    const verb =
+      op === 'create'
+        ? 'Creating'
+        : op === 'append'
+          ? 'Adding'
+          : op === 'patch'
+            ? 'Editing'
+            : op === 'update'
+              ? 'Writing'
+              : op === 'rename'
+                ? 'Renaming'
+                : op === 'delete'
+                  ? 'Deleting'
+                  : 'Writing'
+    const unescaped = titleMatch[1]
+      .replace(/\\u([0-9a-fA-F]{4})/g, (_, hex: string) =>
+        String.fromCharCode(Number.parseInt(hex, 16))
+      )
+      .replace(/\\"/g, '"')
+      .replace(/\\\\/g, '\\')
+    return `${verb} ${unescaped}`
+  }, [toolName, streamingArgs])
+  const extracted = useMemo(() => {
+    if (toolName !== FunctionExecute.id || !streamingArgs) return null
+    return extractFunctionExecutePreview(streamingArgs)
+  }, [toolName, streamingArgs])
+  const markdown = useMemo(
+    () => (extracted ? `\`\`\`${extracted.lang}\n${extracted.code}\n\`\`\`` : null),
+    [extracted]
+  )
+
   return (
     <div className='flex items-center gap-[8px] pl-[24px]'>
       <div className='flex h-[16px] w-[16px] flex-shrink-0 items-center justify-center'>
         <StatusIcon status={status} toolName={toolName} />
       </div>
-      <span className='font-base text-[13px] text-[var(--text-secondary)]'>{displayTitle}</span>
+      <span className='font-base text-[13px] text-[var(--text-secondary)]'>
+        {liveWorkspaceFileTitle || displayTitle}
+      </span>
     </div>
   )
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/chat-content/chat-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/chat-content/chat-content.tsx
index 018967deae2..72e94545d52 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/chat-content/chat-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/chat-content/chat-content.tsx
@@ -1,8 +1,8 @@
 'use client'
 
-import { Children, type ComponentPropsWithoutRef, isValidElement, useMemo } from 'react'
-import ReactMarkdown from 'react-markdown'
-import remarkGfm from 'remark-gfm'
+import { type ComponentPropsWithoutRef, useEffect, useMemo, useRef } from 'react'
+import { Streamdown } from 'streamdown'
+import 'streamdown/styles.css'
 import 'prismjs/components/prism-typescript'
 import 'prismjs/components/prism-bash'
 import 'prismjs/components/prism-css'
@@ -13,15 +13,14 @@ import { CopyCodeButton } from '@/components/ui/copy-code-button'
 import { cn } from '@/lib/core/utils/cn'
 import { extractTextContent } from '@/lib/core/utils/react-node-text'
 import {
+  type ContentSegment,
   PendingTagIndicator,
   parseSpecialTags,
   SpecialTags,
 } from '@/app/workspace/[workspaceId]/home/components/message-content/components/special-tags'
-import { useStreamingReveal } from '@/hooks/use-streaming-reveal'
+import type { MothershipResource } from '@/app/workspace/[workspaceId]/home/types'
 import { useStreamingText } from '@/hooks/use-streaming-text'
 
-const REMARK_PLUGINS = [remarkGfm]
-
 const LANG_ALIASES: Record<string, string> = {
   js: 'javascript',
   ts: 'typescript',
@@ -46,17 +45,55 @@ const PROSE_CLASSES = cn(
   'prose-ul:my-4 prose-ol:my-4',
   'prose-strong:font-[600] prose-strong:text-[var(--text-primary)]',
   'prose-a:text-[var(--text-primary)] prose-a:underline prose-a:decoration-dashed prose-a:underline-offset-4',
-  'prose-code:rounded prose-code:bg-[var(--surface-5)] prose-code:px-1.5 prose-code:py-0.5 prose-code:text-small prose-code:font-mono prose-code:font-[400] prose-code:text-[var(--text-primary)]',
-  'prose-code:before:content-none prose-code:after:content-none',
   'prose-hr:border-[var(--divider)] prose-hr:my-6',
   'prose-table:my-0'
 )
 
+function startsInlineWord(value: string): boolean {
+  return /^[A-Za-z0-9_(]/.test(value)
+}
+
+function endsInlineWord(value: string): boolean {
+  return /[A-Za-z0-9_)]$/.test(value)
+}
+
+function nextInlineSegmentLabel(segment?: ContentSegment): string {
+  if (!segment) return ''
+  if (segment.type === 'text' || segment.type === 'thinking') return segment.content
+  if (segment.type === 'workspace_resource') return segment.data.title || segment.data.id
+  return ''
+}
+
+function appendInlineReferenceMarkdown(
+  currentMarkdown: string,
+  referenceMarkdown: string,
+  nextSegment?: ContentSegment
+): string {
+  let nextMarkdown = currentMarkdown
+  if (currentMarkdown && endsInlineWord(currentMarkdown) && !/\s$/.test(currentMarkdown)) {
+    nextMarkdown += ' '
+  }
+
+  nextMarkdown += referenceMarkdown
+
+  const followingText = nextInlineSegmentLabel(nextSegment)
+  if (
+    followingText &&
+    startsInlineWord(followingText) &&
+    !/^\s/.test(followingText) &&
+    !/\s$/.test(nextMarkdown)
+  ) {
+    nextMarkdown += ' '
+  }
+
+  return nextMarkdown
+}
+
 type TdProps = ComponentPropsWithoutRef<'td'>
 type ThProps = ComponentPropsWithoutRef<'th'>
 
-const MARKDOWN_COMPONENTS: React.ComponentProps<typeof ReactMarkdown>['components'] = {
-  table({ children }) {
+const MARKDOWN_COMPONENTS = {
+  table({ children }: { children?: React.ReactNode }) {
     return (
       <div className='not-prose my-4 w-full overflow-x-auto [&_strong]:font-[600]'>
         <table className='min-w-full border-collapse [&_tbody_tr:last-child_td]:border-b-0'>
@@ -65,7 +102,7 @@ const MARKDOWN_COMPONENTS: React.ComponentProps<typeof ReactMarkdown>['component
       </div>
     )
   },
-  thead({ children }) {
+  thead({ children }: { children?: React.ReactNode }) {
     return <thead>{children}</thead>
   },
   th({ children, style }: ThProps) {
@@ -88,25 +125,15 @@ const MARKDOWN_COMPONENTS: React.ComponentProps<typeof ReactMarkdown>['component
       </td>
     )
   },
-  pre({ children }) {
-    let codeString = ''
-    let language = ''
-
-    for (const child of Children.toArray(children)) {
-      if (isValidElement(child) && child.type === 'code') {
-        const props = child.props as { className?: string; children?: React.ReactNode }
-        codeString = extractTextContent(props.children)
-        if (props.className?.startsWith('language-')) {
-          language = props.className.slice(9)
-        }
-        break
-      }
-    }
+  code({ children, className }: { children?: React.ReactNode; className?: string }) {
+    const langMatch = className?.match(/language-(\w+)/)
+    const language = langMatch ? langMatch[1] : ''
+    const codeString = extractTextContent(children)
 
     if (!codeString) {
       return (
         <pre className='not-prose my-6 overflow-x-auto rounded-lg bg-[var(--surface-5)] p-4 font-[430] font-mono text-[var(--text-primary)] text-small leading-[21px] dark:bg-[var(--code-bg)]'>
-          {children}
+          <code>{children}</code>
         </pre>
       )
     }
@@ -133,7 +160,29 @@ const MARKDOWN_COMPONENTS: React.ComponentProps<typeof ReactMarkdown>['component
       </div>
     )
   },
-  a({ children, href }) {
+  a({ children, href }: { children?: React.ReactNode; href?: string }) {
+    if (href?.startsWith('#wsres-')) {
+      return (
+        <a
+          href={href}
+          className='text-[var(--text-primary)] underline decoration-dashed underline-offset-4'
+          onClick={(e) => {
+            e.preventDefault()
+            const match = href.match(/^#wsres-(\w+)-(.+)$/)
+            if (match) {
+              const linkText = e.currentTarget.textContent || match[2]
+              window.dispatchEvent(
+                new CustomEvent('wsres-click', {
+                  detail: { type: match[1], id: match[2], title: linkText },
+                })
+              )
+            }
+          }}
+        >
+          {children}
+        </a>
+      )
+    }
     return (
       <a
         href={href}
@@ -145,16 +194,16 @@ const MARKDOWN_COMPONENTS: React.ComponentProps<typeof ReactMarkdown>['component
       </a>
     )
   },
-  ul({ children, className }) {
+  ul({ children, className }: { children?: React.ReactNode; className?: string }) {
     if (className?.includes('contains-task-list')) {
       return <ul className='my-4 list-none space-y-2 pl-0'>{children}</ul>
     }
     return <ul className='my-4 list-disc pl-5 marker:text-[var(--text-primary)]'>{children}</ul>
   },
-  ol({ children }) {
+  ol({ children }: { children?: React.ReactNode }) {
     return <ol className='my-4 list-decimal pl-5 marker:text-[var(--text-primary)]'>{children}</ol>
   },
-  li({ children, className }) {
+  li({ children, className }: { children?: React.ReactNode; className?: string }) {
     if (className?.includes('task-list-item')) {
       return (
         <li className='flex list-none items-start gap-2 text-[var(--text-primary)] text-base leading-[25px] [&>p:only-child]:inline [&>p]:my-0'>
@@ -168,7 +217,14 @@ const MARKDOWN_COMPONENTS: React.ComponentProps<typeof ReactMarkdown>['component
       </li>
     )
   },
-  input({ type, checked }) {
+  inlineCode({ children }: { children?: React.ReactNode }) {
+    return (
+      <code className='rounded bg-[var(--surface-5)] px-1.5 py-0.5 font-[400] font-mono text-[var(--text-primary)] text-small before:content-none after:content-none'>
+        {children}
+      </code>
+    )
+  },
+  input({ type, checked }: { type?: string; checked?: boolean }) {
     if (type === 'checkbox') {
       return <Checkbox checked={checked || false} disabled size='sm' className='mt-1.5 shrink-0' />
     }
@@ -180,61 +236,110 @@ interface ChatContentProps {
   content: string
   isStreaming?: boolean
   onOptionSelect?: (id: string) => void
+  onWorkspaceResourceSelect?: (resource: MothershipResource) => void
+  smoothStreaming?: boolean
 }
 
-function MarkdownChunk({
+export function ChatContent({
   content,
-  animate = false,
-  trimTop = true,
-  trimBottom = true,
-}: {
-  content: string
-  animate?: boolean
-  trimTop?: boolean
-  trimBottom?: boolean
-}) {
-  return (
-    <div
-      className={cn(
-        PROSE_CLASSES,
-        trimTop && '[&>:first-child]:mt-0',
-        trimBottom && '[&>:last-child]:mb-0',
-        animate && 'animate-stream-fade-in'
-      )}
-    >
-      <ReactMarkdown remarkPlugins={REMARK_PLUGINS} components={MARKDOWN_COMPONENTS}>
-        {content}
-      </ReactMarkdown>
-    </div>
-  )
-}
+  isStreaming = false,
+  onOptionSelect,
+  onWorkspaceResourceSelect,
+  smoothStreaming = true,
+}: ChatContentProps) {
+  const hydratedStreamingRef = useRef(isStreaming && content.trim().length > 0)
+  const previousIsStreamingRef = useRef(isStreaming)
+
+  useEffect(() => {
+    if (!previousIsStreamingRef.current && isStreaming && content.trim().length > 0) {
+      hydratedStreamingRef.current = true
+    } else if (!isStreaming) {
+      hydratedStreamingRef.current = false
+    }
+    previousIsStreamingRef.current = isStreaming
+  }, [content, isStreaming])
+
+  const onWorkspaceResourceSelectRef = useRef(onWorkspaceResourceSelect)
+  onWorkspaceResourceSelectRef.current = onWorkspaceResourceSelect
+
+  useEffect(() => {
+    const handler = (e: Event) => {
+      const { type, id, title } = (e as CustomEvent).detail
+      const RESOURCE_TYPE_MAP: Record<string, string> = {}
+      onWorkspaceResourceSelectRef.current?.({
+        type: RESOURCE_TYPE_MAP[type] || type,
+        id,
+        title: title || id,
+      })
+    }
+    window.addEventListener('wsres-click', handler)
+    return () => window.removeEventListener('wsres-click', handler)
+  }, [])
 
-export function ChatContent({ content, isStreaming = false, onOptionSelect }: ChatContentProps) {
-  const rendered = useStreamingText(content, isStreaming)
+  const rendered = useStreamingText(content, isStreaming && smoothStreaming)
 
   const parsed = useMemo(() => parseSpecialTags(rendered, isStreaming), [rendered, isStreaming])
   const hasSpecialContent = parsed.hasPendingTag || parsed.segments.some((s) => s.type !== 'text')
 
-  const plainText = hasSpecialContent ? '' : rendered
-  const { committed, incoming, generation } = useStreamingReveal(
-    plainText,
-    !hasSpecialContent && isStreaming
-  )
+  if (hasSpecialContent) {
+    type BlockSegment = Exclude<
+      ContentSegment,
+      { type: 'text' } | { type: 'thinking' } | { type: 'workspace_resource' }
+    >
+    type RenderGroup =
+      | { kind: 'inline'; markdown: string }
+      | { kind: 'block'; segment: BlockSegment; index: number }
 
-  const committedMarkdown = useMemo(
-    () => (committed ? <MarkdownChunk content={committed} trimTop trimBottom={!incoming} /> : null),
-    [committed, incoming]
-  )
+    const groups: RenderGroup[] = []
+    let pendingMarkdown = ''
+
+    const flushMarkdown = () => {
+      if (pendingMarkdown.trim()) {
+        groups.push({ kind: 'inline', markdown: pendingMarkdown })
+      }
+      pendingMarkdown = ''
+    }
+
+    for (let i = 0; i < parsed.segments.length; i++) {
+      const s = parsed.segments[i]
+      const nextSegment = parsed.segments[i + 1]
+      if (s.type === 'workspace_resource') {
+        const label = s.data.title || s.data.id
+        pendingMarkdown = appendInlineReferenceMarkdown(
+          pendingMarkdown,
+          `[${label}](#wsres-${s.data.type}-${s.data.id})`,
+          nextSegment
+        )
+      } else if (s.type === 'text' || s.type === 'thinking') {
+        pendingMarkdown += s.content
+      } else {
+        flushMarkdown()
+        groups.push({ kind: 'block', segment: s, index: i })
+      }
+    }
+    flushMarkdown()
 
-  if (hasSpecialContent) {
     return (
       <div className='space-y-3'>
-        {parsed.segments.map((segment, i) => {
-          if (segment.type === 'text' || segment.type === 'thinking') {
-            return <MarkdownChunk key={`${segment.type}-${i}`} content={segment.content} />
+        {groups.map((group, i) => {
+          if (group.kind === 'inline') {
+            return (
+              <div
+                key={`inline-${i}`}
+                className={cn(PROSE_CLASSES, '[&>:first-child]:mt-0 [&>:last-child]:mb-0')}
+              >
+                <Streamdown mode='static' components={MARKDOWN_COMPONENTS}>
+                  {group.markdown}
+                </Streamdown>
+              </div>
+            )
           }
           return (
-            <SpecialTags key={`special-${i}`} segment={segment} onOptionSelect={onOptionSelect} />
+            <SpecialTags
+              key={`special-${group.index}`}
+              segment={group.segment}
+              onOptionSelect={onOptionSelect}
+            />
           )
         })}
         {parsed.hasPendingTag && isStreaming && <PendingTagIndicator />}
@@ -243,17 +348,15 @@ export function ChatContent({ content, isStreaming = false, onOptionSelect }: Ch
   }
 
   return (
-    <div>
-      {committedMarkdown}
-      {incoming && (
-        <MarkdownChunk
-          key={generation}
-          content={incoming}
-          trimTop
-          trimBottom
-          animate={isStreaming}
-        />
-      )}
+    <div className={cn(PROSE_CLASSES, '[&>:first-child]:mt-0 [&>:last-child]:mb-0')}>
+      <Streamdown
+        mode={isStreaming ? undefined : 'static'}
+        isAnimating={isStreaming}
+        animated={isStreaming && !hydratedStreamingRef.current}
+        components={MARKDOWN_COMPONENTS}
+      >
+        {rendered}
+      </Streamdown>
     </div>
   )
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/index.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/index.ts
index 473bd7493a1..c45b9199c31 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/index.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/index.ts
@@ -9,6 +9,8 @@ export type {
   RuntimeSpecialTagName,
   UsageUpgradeAction,
   UsageUpgradeTagData,
+  WorkspaceResourceTagData,
+  WorkspaceResourceTagType,
 } from './special-tags'
 export {
   CREDENTIAL_TAG_TYPES,
@@ -20,4 +22,6 @@ export {
   parseTextTagBody,
   SpecialTags,
   USAGE_UPGRADE_ACTIONS,
+  WORKSPACE_RESOURCE_TAG_TYPES,
+  WorkspaceResourceDisplay,
 } from './special-tags'
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx
index dc6a032bc67..d5261300461 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx
@@ -1,10 +1,19 @@
 'use client'
 
-import { createElement, useState } from 'react'
+import { createElement, useEffect, useMemo, useState } from 'react'
 import { useParams } from 'next/navigation'
 import { ArrowRight, ChevronDown, Expandable, ExpandableContent } from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import { OAUTH_PROVIDERS } from '@/lib/oauth/oauth'
+import { ContextMentionIcon } from '@/app/workspace/[workspaceId]/home/components/context-mention-icon'
+import type {
+  ChatMessageContext,
+  MothershipResource,
+} from '@/app/workspace/[workspaceId]/home/types'
+import { useKnowledgeBasesQuery } from '@/hooks/queries/kb/knowledge'
+import { useTablesList } from '@/hooks/queries/tables'
+import { useWorkflows } from '@/hooks/queries/workflows'
+import { useWorkspaceFiles } from '@/hooks/queries/workspace-files'
 
 export interface OptionsItemData {
   title: string
@@ -55,6 +64,16 @@ export interface FileTagData {
   content: string
 }
 
+export const WORKSPACE_RESOURCE_TAG_TYPES = ['workflow', 'table', 'file'] as const
+
+export type WorkspaceResourceTagType = (typeof WORKSPACE_RESOURCE_TAG_TYPES)[number]
+
+export interface WorkspaceResourceTagData {
+  type: WorkspaceResourceTagType
+  id: string
+  title?: string
+}
+
 export type ContentSegment =
   | { type: 'text'; content: string }
   | { type: 'thinking'; content: string }
@@ -62,6 +81,7 @@ export type ContentSegment =
   | { type: 'usage_upgrade'; data: UsageUpgradeTagData }
   | { type: 'credential'; data: CredentialTagData }
   | { type: 'mothership-error'; data: MothershipErrorTagData }
+  | { type: 'workspace_resource'; data: WorkspaceResourceTagData }
 
 export type RuntimeSpecialTagName =
   | 'thinking'
@@ -69,6 +89,7 @@ export type RuntimeSpecialTagName =
   | 'credential'
   | 'mothership-error'
   | 'file'
+  | 'workspace_resource'
 
 export interface ParsedSpecialContent {
   segments: ContentSegment[]
@@ -81,6 +102,7 @@ const RUNTIME_SPECIAL_TAG_NAMES = [
   'credential',
   'mothership-error',
   'file',
+  'workspace_resource',
 ] as const
 
 const SPECIAL_TAG_NAMES = [
@@ -89,6 +111,7 @@ const SPECIAL_TAG_NAMES = [
   'usage_upgrade',
   'credential',
   'mothership-error',
+  'workspace_resource',
 ] as const
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -134,6 +157,16 @@ function isMothershipErrorTagData(value: unknown): value is MothershipErrorTagDa
   )
 }
 
+function isWorkspaceResourceTagData(value: unknown): value is WorkspaceResourceTagData {
+  if (!isRecord(value)) return false
+  return (
+    typeof value.type === 'string' &&
+    (WORKSPACE_RESOURCE_TAG_TYPES as readonly string[]).includes(value.type) &&
+    typeof value.id === 'string' &&
+    value.id.trim().length > 0
+  )
+}
+
 export function parseJsonTagBody<T>(
   body: string,
   isExpectedShape: (value: unknown) => value is T
@@ -181,6 +214,7 @@ function parseSpecialTagData(
   | { type: 'usage_upgrade'; data: UsageUpgradeTagData }
   | { type: 'credential'; data: CredentialTagData }
   | { type: 'mothership-error'; data: MothershipErrorTagData }
+  | { type: 'workspace_resource'; data: WorkspaceResourceTagData }
   | null {
   if (tagName === 'thinking') {
     const content = parseTextTagBody(body)
@@ -207,11 +241,16 @@ function parseSpecialTagData(
     return data ? { type: 'mothership-error', data } : null
   }
 
+  if (tagName === 'workspace_resource') {
+    const data = parseJsonTagBody(body, isWorkspaceResourceTagData)
+    return data ? { type: 'workspace_resource', data } : null
+  }
+
   return null
 }
 
 /**
- * Parses inline special tags (`<options>`, `<usage_upgrade>`) from streamed
+ * Parses inline special tags (`<options>`, `<usage_upgrade>`, `<workspace_resource>`) from streamed
  * text content. Complete tags are extracted into typed segments; incomplete
  * tags (still streaming) are suppressed from display and flagged via
  * `hasPendingTag` so the caller can show a loading indicator.
@@ -307,12 +346,18 @@ const THINKING_BLOCKS = [
 interface SpecialTagsProps {
   segment: Exclude<ContentSegment, { type: 'text' }>
   onOptionSelect?: (id: string) => void
+  onWorkspaceResourceSelect?: (resource: MothershipResource) => void
 }
 
 /**
- * Unified renderer for inline special tags: `<options>`, `<usage_upgrade>`, and `<credential>`.
+ * Unified renderer for inline special tags: `<options>`, `<usage_upgrade>`, `<credential>`,
+ * and `<workspace_resource>`.
  */
-export function SpecialTags({ segment, onOptionSelect }: SpecialTagsProps) {
+export function SpecialTags({
+  segment,
+  onOptionSelect,
+  onWorkspaceResourceSelect,
+}: SpecialTagsProps) {
   switch (segment.type) {
     case 'thinking':
       return null
@@ -324,6 +369,8 @@ export function SpecialTags({ segment, onOptionSelect }: SpecialTagsProps) {
       return <CredentialDisplay data={segment.data} />
     case 'mothership-error':
       return <MothershipErrorDisplay data={segment.data} />
+    case 'workspace_resource':
+      return <WorkspaceResourceDisplay data={segment.data} onSelect={onWorkspaceResourceSelect} />
     default:
       return null
   }
@@ -358,6 +405,13 @@ function OptionsDisplay({ data, onSelect }: OptionsDisplayProps) {
   const disabled = !onSelect
   const [expanded, setExpanded] = useState(!disabled)
   const entries = Object.entries(data)
+
+  useEffect(() => {
+    if (!disabled) {
+      setExpanded(true)
+    }
+  }, [disabled])
+
   if (entries.length === 0) return null
 
   return (
@@ -413,6 +467,102 @@ function OptionsDisplay({ data, onSelect }: OptionsDisplayProps) {
   )
 }
 
+function fallbackWorkspaceResourceTitle(type: WorkspaceResourceTagType): string {
+  switch (type) {
+    case 'workflow':
+      return 'Workflow'
+    case 'table':
+      return 'Table'
+    case 'file':
+      return 'File'
+  }
+}
+
+function toMothershipResourceType(type: WorkspaceResourceTagType): MothershipResource['type'] {
+  return type
+}
+
+function toChatMessageContext(data: WorkspaceResourceTagData, label: string): ChatMessageContext {
+  switch (data.type) {
+    case 'workflow':
+      return { kind: 'workflow', label, workflowId: data.id }
+    case 'table':
+      return { kind: 'table', label, tableId: data.id }
+    case 'file':
+      return { kind: 'file', label, fileId: data.id }
+  }
+}
+
+export function WorkspaceResourceDisplay({
+  data,
+  onSelect,
+}: {
+  data: WorkspaceResourceTagData
+  onSelect?: (resource: MothershipResource) => void
+}) {
+  const { workspaceId } = useParams<{ workspaceId: string }>()
+  const { data: workflows = [] } = useWorkflows(workspaceId)
+  const { data: tables = [] } = useTablesList(workspaceId)
+  const { data: files = [] } = useWorkspaceFiles(workspaceId)
+  const { data: knowledgeBases = [] } = useKnowledgeBasesQuery(workspaceId)
+
+  const resource = useMemo<MothershipResource>(() => {
+    const title =
+      data.type === 'workflow'
+        ? (workflows.find((workflow) => workflow.id === data.id)?.name ??
+          fallbackWorkspaceResourceTitle(data.type))
+        : data.type === 'table'
+          ? (tables.find((table) => table.id === data.id)?.name ??
+            fallbackWorkspaceResourceTitle(data.type))
+          : data.type === 'file'
+            ? (files.find((file) => file.id === data.id)?.name ??
+              fallbackWorkspaceResourceTitle(data.type))
+            : (knowledgeBases.find((knowledgeBase) => knowledgeBase.id === data.id)?.name ??
+              fallbackWorkspaceResourceTitle(data.type))
+
+    return {
+      type: toMothershipResourceType(data.type),
+      id: data.id,
+      title,
+    }
+  }, [data.id, data.type, files, knowledgeBases, tables, workflows])
+
+  const context = useMemo(() => toChatMessageContext(data, resource.title), [data, resource.title])
+
+  const workflowColor = useMemo(() => {
+    if (data.type !== 'workflow') return null
+    return workflows.find((workflow) => workflow.id === data.id)?.color ?? null
+  }, [data.id, data.type, workflows])
+
+  const mentionContent = (
+    <>
+      <ContextMentionIcon
+        context={context}
+        workflowColor={workflowColor}
+        className='relative top-0.5 h-[12px] w-[12px] flex-shrink-0 text-[var(--text-icon)]'
+      />
+      {resource.title}
+    </>
+  )
+
+  const classes =
+    'inline-flex items-baseline gap-1 rounded-[5px] bg-[var(--surface-5)] px-[5px] align-baseline font-[inherit] text-[inherit] leading-[inherit]'
+
+  if (!onSelect) {
+    return <span className={classes}>{mentionContent}</span>
+  }
+
+  return (
+    <button
+      type='button'
+      onClick={() => onSelect(resource)}
+      className={cn(classes, 'cursor-pointer transition-colors hover-hover:bg-[var(--surface-6)]')}
+    >
+      {mentionContent}
+    </button>
+  )
+}
+
 function getCredentialIcon(provider: string): React.ComponentType<{ className?: string }> | null {
   const lower = provider.toLowerCase()
 
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
index 83d19f44aa8..7f3d13f7dc1 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
@@ -1,21 +1,18 @@
 'use client'
 
-import type { AgentGroupItem } from '@/app/workspace/[workspaceId]/home/components/message-content/components'
 import {
-  AgentGroup,
-  ChatContent,
-  CircleStop,
-  Options,
-  PendingTagIndicator,
-} from '@/app/workspace/[workspaceId]/home/components/message-content/components'
-import type {
-  ContentBlock,
-  MothershipToolName,
-  OptionItem,
-  SubagentName,
-  ToolCallData,
-} from '@/app/workspace/[workspaceId]/home/types'
-import { SUBAGENT_LABELS, TOOL_UI_METADATA } from '@/app/workspace/[workspaceId]/home/types'
+  Read as ReadTool,
+  ToolSearchToolRegex,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
+import { resolveToolDisplay } from '@/lib/copilot/tools/client/store-utils'
+import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
+import type { ContentBlock, MothershipResource, OptionItem, ToolCallData } from '../../types'
+import { SUBAGENT_LABELS, TOOL_UI_METADATA } from '../../types'
+import type { AgentGroupItem } from './components'
+import { AgentGroup, ChatContent, CircleStop, Options, PendingTagIndicator } from './components'
+
+const FILE_SUBAGENT_ID = 'file'
 
 interface TextSegment {
   type: 'text'
@@ -47,16 +44,29 @@ const SUBAGENT_KEYS = new Set(Object.keys(SUBAGENT_LABELS))
 
 /**
  * Maps subagent names to the Mothership tool that dispatches them when the
- * tool name differs from the subagent name (e.g. `workspace_file` → `file_write`).
+ * tool name differs from the subagent name (e.g. `workspace_file` → `file`).
  * When a `subagent` block arrives, any trailing dispatch tool in the previous
  * group is absorbed so it doesn't render as a separate Mothership entry.
  */
 const SUBAGENT_DISPATCH_TOOLS: Record<string, string> = {
-  file_write: 'workspace_file',
+  [FILE_SUBAGENT_ID]: WorkspaceFile.id,
+}
+
+function isToolResultRead(params?: Record<string, unknown>): boolean {
+  const path = params?.path
+  return typeof path === 'string' && path.startsWith('internal/tool-results/')
+}
+
+function formatToolName(name: string): string {
+  return name
+    .replace(/_v\d+$/, '')
+    .split('_')
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ')
 }
 
 function resolveAgentLabel(key: string): string {
-  return SUBAGENT_LABELS[key as SubagentName] ?? key
+  return SUBAGENT_LABELS[key] ?? formatToolName(key)
 }
 
 function isToolDone(status: ToolCallData['status']): boolean {
@@ -67,12 +77,41 @@ function isDelegatingTool(tc: NonNullable<ContentBlock['toolCall']>): boolean {
   return tc.status === 'executing'
 }
 
+function mapToolStatusToClientState(
+  status: ContentBlock['toolCall'] extends { status: infer T } ? T : string
+) {
+  switch (status) {
+    case 'success':
+      return ClientToolCallState.success
+    case 'error':
+      return ClientToolCallState.error
+    case 'cancelled':
+      return ClientToolCallState.cancelled
+    default:
+      return ClientToolCallState.executing
+  }
+}
+
+function getOverrideDisplayTitle(tc: NonNullable<ContentBlock['toolCall']>): string | undefined {
+  if (tc.name === ReadTool.id || tc.name === 'respond' || tc.name.endsWith('_respond')) {
+    return resolveToolDisplay(tc.name, mapToolStatusToClientState(tc.status), tc.id, tc.params)
+      ?.text
+  }
+  return undefined
+}
+
 function toToolData(tc: NonNullable<ContentBlock['toolCall']>): ToolCallData {
+  const overrideDisplayTitle = getOverrideDisplayTitle(tc)
+  const displayTitle =
+    overrideDisplayTitle ||
+    tc.displayTitle ||
+    TOOL_UI_METADATA[tc.name as keyof typeof TOOL_UI_METADATA]?.title ||
+    formatToolName(tc.name)
+
   return {
     id: tc.id,
     toolName: tc.name,
-    displayTitle:
-      tc.displayTitle ?? TOOL_UI_METADATA[tc.name as MothershipToolName]?.title ?? tc.name,
+    displayTitle,
     status: tc.status,
     params: tc.params,
     result: tc.result,
@@ -172,7 +211,8 @@ function parseBlocks(blocks: ContentBlock[]): MessageSegment[] {
     if (block.type === 'tool_call') {
       if (!block.toolCall) continue
       const tc = block.toolCall
-      if (tc.name === 'tool_search_tool_regex') continue
+      if (tc.name === ToolSearchToolRegex.id) continue
+      if (tc.name === ReadTool.id && isToolResultRead(tc.params)) continue
       const isDispatch = SUBAGENT_KEYS.has(tc.name) && !tc.calledBy
 
       if (isDispatch) {
@@ -292,6 +332,7 @@ interface MessageContentProps {
   fallbackContent: string
   isStreaming: boolean
   onOptionSelect?: (id: string) => void
+  onWorkspaceResourceSelect?: (resource: MothershipResource) => void
 }
 
 export function MessageContent({
@@ -299,6 +340,7 @@ export function MessageContent({
   fallbackContent,
   isStreaming = false,
   onOptionSelect,
+  onWorkspaceResourceSelect,
 }: MessageContentProps) {
   const parsed = blocks.length > 0 ? parseBlocks(blocks) : []
 
@@ -312,7 +354,7 @@ export function MessageContent({
   if (segments.length === 0) {
     if (isStreaming) {
       return (
-        <div className='space-y-2.5'>
+        <div className='space-y-[10px]'>
           <PendingTagIndicator />
         </div>
       )
@@ -333,6 +375,7 @@ export function MessageContent({
   const hasSubagentEnded = blocks.some((b) => b.type === 'subagent_end')
   const showTrailingThinking =
     isStreaming && !hasTrailingContent && (hasSubagentEnded || allLastGroupToolsDone)
+  const hasStructuredSegments = segments.some((segment) => segment.type !== 'text')
   const lastOpenSubagentGroupId = [...segments]
     .reverse()
     .find(
@@ -341,7 +384,7 @@ export function MessageContent({
     )?.id
 
   return (
-    <div className='space-y-2.5'>
+    <div className='space-y-[10px]'>
       {segments.map((segment, i) => {
         switch (segment.type) {
           case 'text':
@@ -351,6 +394,8 @@ export function MessageContent({
                 content={segment.content}
                 isStreaming={isStreaming}
                 onOptionSelect={onOptionSelect}
+                onWorkspaceResourceSelect={onWorkspaceResourceSelect}
+                smoothStreaming={!hasStructuredSegments}
               />
             )
           case 'agent_group': {
@@ -384,9 +429,11 @@ export function MessageContent({
             )
           case 'stopped':
             return (
-              <div key={`stopped-${i}`} className='flex items-center gap-2'>
+              <div key={`stopped-${i}`} className='flex items-center gap-[8px]'>
                 <CircleStop className='h-[16px] w-[16px] flex-shrink-0 text-[var(--text-icon)]' />
-                <span className='font-base text-[var(--text-body)] text-sm'>Stopped by user</span>
+                <span className='font-base text-[14px] text-[var(--text-body)]'>
+                  Stopped by user
+                </span>
               </div>
             )
         }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
index 0c7807a576d..12a491b7d28 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
@@ -2,9 +2,7 @@ import type { ComponentType, SVGProps } from 'react'
 import {
   Asterisk,
   Blimp,
-  Bug,
   Calendar,
-  ClipboardList,
   Database,
   Eye,
   File,
@@ -23,106 +21,42 @@ import {
 } from '@/components/emcn'
 import { Table as TableIcon } from '@/components/emcn/icons'
 import { AgentIcon } from '@/components/icons'
-import type { MothershipToolName, SubagentName } from '@/app/workspace/[workspaceId]/home/types'
 
 export type IconComponent = ComponentType<SVGProps<SVGSVGElement>>
 
-const TOOL_ICONS: Record<MothershipToolName | SubagentName | 'mothership', IconComponent> = {
+const TOOL_ICONS: Record<string, IconComponent> = {
   mothership: Blimp,
-  // Workspace
   glob: FolderCode,
   grep: Search,
   read: File,
-  // Search
   search_online: Search,
   scrape_page: Search,
   get_page_contents: Search,
   search_library_docs: Library,
-  crawl_website: Search,
-  // Execution
+  manage_mcp_tool: Settings,
+  manage_skill: Asterisk,
+  user_memory: Database,
   function_execute: TerminalWindow,
   superagent: Blimp,
-  run_workflow: PlayOutline,
-  run_block: PlayOutline,
-  run_from_block: PlayOutline,
-  run_workflow_until_block: PlayOutline,
-  complete_job: PlayOutline,
-  get_execution_summary: ClipboardList,
-  get_job_logs: ClipboardList,
-  get_workflow_logs: ClipboardList,
-  get_workflow_data: Layout,
-  get_block_outputs: ClipboardList,
-  get_block_upstream_references: ClipboardList,
-  get_deployed_workflow_state: Rocket,
-  check_deployment_status: Rocket,
-  // Workflows & folders
+  user_table: TableIcon,
+  workspace_file: File,
+  edit_content: File,
   create_workflow: Layout,
-  delete_workflow: Layout,
   edit_workflow: Pencil,
-  rename_workflow: Pencil,
-  move_workflow: Layout,
-  create_folder: FolderCode,
-  delete_folder: FolderCode,
-  move_folder: FolderCode,
-  list_folders: FolderCode,
-  list_user_workspaces: Layout,
-  revert_to_version: Rocket,
-  get_deployment_version: Rocket,
-  open_resource: Eye,
-  // Files
-  workspace_file: File,
-  download_to_workspace_file: File,
-  materialize_file: File,
-  generate_image: File,
-  generate_visualization: File,
-  // Tables & knowledge
-  user_table: TableIcon,
-  knowledge_base: Database,
-  // Jobs
-  create_job: Calendar,
-  manage_job: Calendar,
-  update_job_history: Calendar,
-  job_respond: Calendar,
-  // Management
-  manage_mcp_tool: Settings,
-  manage_skill: Asterisk,
-  manage_credential: Integration,
-  manage_custom_tool: Wrench,
-  update_workspace_mcp_server: Settings,
-  delete_workspace_mcp_server: Settings,
-  create_workspace_mcp_server: Settings,
-  list_workspace_mcp_servers: Settings,
-  oauth_get_auth_link: Integration,
-  oauth_request_access: Integration,
-  set_environment_variables: Settings,
-  set_global_workflow_variables: Settings,
-  get_platform_actions: Settings,
-  search_documentation: Library,
-  search_patterns: Search,
-  deploy_api: Rocket,
-  deploy_chat: Rocket,
-  deploy_mcp: Rocket,
-  redeploy: Rocket,
-  generate_api_key: Asterisk,
-  user_memory: Database,
-  context_write: Pencil,
-  context_compaction: Asterisk,
-  // Subagents
-  build: Hammer,
+  workflow: Hammer,
   run: PlayOutline,
   deploy: Rocket,
   auth: Integration,
   knowledge: Database,
+  knowledge_base: Database,
   table: TableIcon,
   job: Calendar,
   agent: AgentIcon,
   custom_tool: Wrench,
   research: Search,
-  plan: ClipboardList,
-  debug: Bug,
-  edit: Pencil,
-  fast_edit: Pencil,
-  file_write: File,
+  context_compaction: Asterisk,
+  open_resource: Eye,
+  file: File,
 }
 
 export function getAgentIcon(name: string): IconComponent {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat-skeleton.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat-skeleton.tsx
new file mode 100644
index 00000000000..6a940e8bc35
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat-skeleton.tsx
@@ -0,0 +1,51 @@
+import { Skeleton } from '@/components/emcn'
+
+const LAYOUT_SKELETON_STYLES = {
+  'mothership-view': {
+    content: 'mx-auto max-w-[42rem] space-y-6',
+    userRow: 'flex flex-col items-end gap-[6px] pt-3',
+  },
+  'copilot-view': {
+    content: 'space-y-4',
+    userRow: 'flex flex-col items-end gap-[6px] pt-2',
+  },
+} as const
+
+interface MothershipChatSkeletonProps {
+  layout?: 'mothership-view' | 'copilot-view'
+}
+
+/**
+ * Skeleton content rendered inside MothershipChat's scroll area
+ * while chat history is being fetched.
+ */
+export function MothershipChatSkeleton({
+  layout = 'mothership-view',
+}: MothershipChatSkeletonProps) {
+  const styles = LAYOUT_SKELETON_STYLES[layout]
+
+  return (
+    <div className={styles.content}>
+      <div className={styles.userRow}>
+        <Skeleton className='h-[40px] w-[55%] rounded-[16px]' />
+      </div>
+
+      <div className='space-y-3'>
+        <Skeleton className='h-[14px] w-[90%] rounded-[4px]' />
+        <Skeleton className='h-[14px] w-[75%] rounded-[4px]' />
+        <Skeleton className='h-[14px] w-[82%] rounded-[4px]' />
+        <Skeleton className='h-[14px] w-[40%] rounded-[4px]' />
+      </div>
+
+      <div className={styles.userRow}>
+        <Skeleton className='h-[32px] w-[40%] rounded-[16px]' />
+      </div>
+
+      <div className='space-y-3'>
+        <Skeleton className='h-[14px] w-[85%] rounded-[4px]' />
+        <Skeleton className='h-[14px] w-[70%] rounded-[4px]' />
+        <Skeleton className='h-[14px] w-[60%] rounded-[4px]' />
+      </div>
+    </div>
+  )
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
index fe8510c1990..1030d3951ad 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
@@ -15,15 +15,18 @@ import { UserMessageContent } from '@/app/workspace/[workspaceId]/home/component
 import type {
   ChatMessage,
   FileAttachmentForApi,
+  MothershipResource,
   QueuedMessage,
 } from '@/app/workspace/[workspaceId]/home/types'
 import { useAutoScroll } from '@/hooks/use-auto-scroll'
 import type { ChatContext } from '@/stores/panel'
+import { MothershipChatSkeleton } from './mothership-chat-skeleton'
 
 interface MothershipChatProps {
   messages: ChatMessage[]
   isSending: boolean
   isReconnecting?: boolean
+  isLoading?: boolean
   onSubmit: (
     text: string,
     fileAttachments?: FileAttachmentForApi[],
@@ -38,6 +41,7 @@ interface MothershipChatProps {
   chatId?: string
   onContextAdd?: (context: ChatContext) => void
   onContextRemove?: (context: ChatContext) => void
+  onWorkspaceResourceSelect?: (resource: MothershipResource) => void
   editValue?: string
   onEditValueConsumed?: () => void
   layout?: 'mothership-view' | 'copilot-view'
@@ -75,6 +79,7 @@ export function MothershipChat({
   messages,
   isSending,
   isReconnecting = false,
+  isLoading = false,
   onSubmit,
   onStopGeneration,
   messageQueue,
@@ -85,6 +90,7 @@ export function MothershipChat({
   chatId,
   onContextAdd,
   onContextRemove,
+  onWorkspaceResourceSelect,
   editValue,
   onEditValueConsumed,
   layout = 'mothership-view',
@@ -100,18 +106,11 @@ export function MothershipChat({
   })
   const hasMessages = messages.length > 0
   const initialScrollDoneRef = useRef(false)
-
-  const messageQueueRef = useRef(messageQueue)
-  messageQueueRef.current = messageQueue
-  const onSendQueuedMessageRef = useRef(onSendQueuedMessage)
-  onSendQueuedMessageRef.current = onSendQueuedMessage
-
-  const handleEnterWhileEmpty = useCallback(() => {
-    const topMessage = messageQueueRef.current[0]
-    if (!topMessage) return false
-    void onSendQueuedMessageRef.current(topMessage.id)
-    return true
-  }, [])
+  const handleSendQueuedHead = useCallback(() => {
+    const topMessage = messageQueue[0]
+    if (!topMessage) return
+    void onSendQueuedMessage(topMessage.id)
+  }, [messageQueue, onSendQueuedMessage])
 
   useLayoutEffect(() => {
     if (!hasMessages) {
@@ -126,69 +125,75 @@ export function MothershipChat({
   return (
     <div className={cn('flex h-full min-h-0 flex-col', className)}>
       <div ref={scrollContainerRef} className={styles.scrollContainer}>
-        <div className={styles.content}>
-          {messages.map((msg, index) => {
-            if (msg.role === 'user') {
-              const hasAttachments = Boolean(msg.attachments?.length)
-              return (
-                <div key={msg.id} className={styles.userRow}>
-                  {hasAttachments && (
-                    <ChatMessageAttachments
-                      attachments={msg.attachments ?? []}
-                      align='end'
-                      className={styles.attachmentWidth}
-                    />
-                  )}
-                  <div className={styles.userBubble}>
-                    <UserMessageContent content={msg.content} contexts={msg.contexts} />
+        {isLoading && !hasMessages ? (
+          <MothershipChatSkeleton layout={layout} />
+        ) : (
+          <div className={styles.content}>
+            {messages.map((msg, index) => {
+              if (msg.role === 'user') {
+                const hasAttachments = Boolean(msg.attachments?.length)
+                return (
+                  <div key={msg.id} className={styles.userRow}>
+                    {hasAttachments && (
+                      <ChatMessageAttachments
+                        attachments={msg.attachments ?? []}
+                        align='end'
+                        className={styles.attachmentWidth}
+                      />
+                    )}
+                    <div className={styles.userBubble}>
+                      <UserMessageContent content={msg.content} contexts={msg.contexts} />
+                    </div>
                   </div>
-                </div>
-              )
-            }
+                )
+              }
 
-            const hasAnyBlocks = Boolean(msg.contentBlocks?.length)
-            const hasRenderableAssistant = assistantMessageHasRenderableContent(
-              msg.contentBlocks ?? [],
-              msg.content ?? ''
-            )
-            const isLastAssistant = index === messages.length - 1
-            const isThisStreaming = isStreamActive && isLastAssistant
+              const hasAnyBlocks = Boolean(msg.contentBlocks?.length)
+              const hasRenderableAssistant = assistantMessageHasRenderableContent(
+                msg.contentBlocks ?? [],
+                msg.content ?? ''
+              )
+              const isLastAssistant = index === messages.length - 1
+              const isThisStreaming = isStreamActive && isLastAssistant
 
-            if (!hasAnyBlocks && !msg.content?.trim() && isThisStreaming) {
-              return <PendingTagIndicator key={msg.id} />
-            }
+              if (!hasAnyBlocks && !msg.content?.trim() && isThisStreaming) {
+                return <PendingTagIndicator key={msg.id} />
+              }
 
-            if (!hasRenderableAssistant && !msg.content?.trim() && !isThisStreaming) {
-              return null
-            }
+              if (!hasRenderableAssistant && !msg.content?.trim() && !isThisStreaming) {
+                return null
+              }
 
-            const isLastMessage = index === messages.length - 1
-            const precedingUserMsg = [...messages]
-              .slice(0, index)
-              .reverse()
-              .find((m) => m.role === 'user')
+              const isLastMessage = index === messages.length - 1
+              const precedingUserMsg = [...messages]
+                .slice(0, index)
+                .reverse()
+                .find((m) => m.role === 'user')
 
-            return (
-              <div key={msg.id} className={styles.assistantRow}>
-                <MessageContent
-                  blocks={msg.contentBlocks || []}
-                  fallbackContent={msg.content}
-                  isStreaming={isThisStreaming}
-                  onOptionSelect={isLastMessage ? onSubmit : undefined}
-                />
-                {!isThisStreaming && (msg.content || msg.contentBlocks?.length) && (
-                  <div className='mt-2.5'>
-                    <MessageActions
-                      content={msg.content}
-                      chatId={chatId}
-                      userQuery={precedingUserMsg?.content}
-                    />
-                  </div>
-                )}
-              </div>
-            )
-          })}
-        </div>
+              return (
+                <div key={msg.id} className={styles.assistantRow}>
+                  <MessageContent
+                    blocks={msg.contentBlocks || []}
+                    fallbackContent={msg.content}
+                    isStreaming={isThisStreaming}
+                    onOptionSelect={isLastMessage && !isStreamActive ? onSubmit : undefined}
+                    onWorkspaceResourceSelect={onWorkspaceResourceSelect}
+                  />
+                  {!isThisStreaming && (msg.content || msg.contentBlocks?.length) && (
+                    <div className='mt-2.5'>
+                      <MessageActions
+                        content={msg.content}
+                        chatId={chatId}
+                        userQuery={precedingUserMsg?.content}
+                        requestId={msg.requestId}
+                      />
+                    </div>
+                  )}
+                </div>
+              )
+            })}
+          </div>
+        )}
       </div>
 
       <div
@@ -212,7 +217,7 @@ export function MothershipChat({
             onContextRemove={onContextRemove}
             editValue={editValue}
             onEditValueConsumed={onEditValueConsumed}
-            onEnterWhileEmpty={handleEnterWhileEmpty}
+            onSendQueuedHead={handleSendQueuedHead}
           />
         </div>
       </div>
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
index ab2655ed48d..4b25c0affcc 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
@@ -1,22 +1,28 @@
 'use client'
 
-import { lazy, memo, Suspense, useCallback, useEffect, useMemo } from 'react'
+import { lazy, memo, Suspense, useCallback, useEffect, useMemo, useState } from 'react'
 import { createLogger } from '@sim/logger'
 import { Square } from 'lucide-react'
 import { useRouter } from 'next/navigation'
-import { Button, PlayOutline, Skeleton, Tooltip } from '@/components/emcn'
+import { Button, Eye, PlayOutline, Skeleton, Tooltip } from '@/components/emcn'
 import {
   Download,
   FileX,
   Folder as FolderIcon,
+  Library,
   SquareArrowUpRight,
   WorkflowX,
 } from '@/components/emcn/icons'
+import { BASE_EXECUTION_CHARGE } from '@/lib/billing/constants'
+import type { FilePreviewSession } from '@/lib/copilot/request/session'
 import {
   cancelRunToolExecution,
   markRunToolManuallyStopped,
   reportManualRunToolStop,
-} from '@/lib/copilot/client-sse/run-tool-execution'
+} from '@/lib/copilot/tools/client/run-tool-execution'
+import { cn } from '@/lib/core/utils/cn'
+import { formatDuration } from '@/lib/core/utils/formatting'
+import { filterHiddenOutputKeys } from '@/lib/logs/execution/trace-spans/trace-spans'
 import {
   downloadWorkspaceFile,
   getFileExtension,
@@ -37,6 +43,18 @@ import type {
   MothershipResource,
 } from '@/app/workspace/[workspaceId]/home/types'
 import { KnowledgeBase } from '@/app/workspace/[workspaceId]/knowledge/[id]/base'
+import {
+  ExecutionSnapshot,
+  FileCards,
+  TraceSpans,
+  WorkflowOutputSection,
+} from '@/app/workspace/[workspaceId]/logs/components'
+import {
+  formatDate,
+  getDisplayStatus,
+  StatusBadge,
+  TriggerBadge,
+} from '@/app/workspace/[workspaceId]/logs/utils'
 import {
   useUserPermissionsContext,
   useWorkspacePermissionsContext,
@@ -45,9 +63,11 @@ import { Table } from '@/app/workspace/[workspaceId]/tables/[tableId]/components
 import { useUsageLimits } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/hooks'
 import { useWorkflowExecution } from '@/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution'
 import { useFolders } from '@/hooks/queries/folders'
+import { useLogDetail } from '@/hooks/queries/logs'
 import { useWorkflows } from '@/hooks/queries/workflows'
 import { useWorkspaceFiles } from '@/hooks/queries/workspace-files'
 import { useSettingsNavigation } from '@/hooks/use-settings-navigation'
+import { formatCost } from '@/providers/utils'
 import { useExecutionStore } from '@/stores/execution/store'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 
@@ -65,8 +85,9 @@ interface ResourceContentProps {
   workspaceId: string
   resource: MothershipResource
   previewMode?: PreviewMode
-  streamingFile?: { fileName: string; content: string } | null
+  previewSession?: FilePreviewSession | null
   genericResourceData?: GenericResourceData
+  previewContextKey?: string
 }
 
 /**
@@ -80,18 +101,19 @@ export const ResourceContent = memo(function ResourceContent({
   workspaceId,
   resource,
   previewMode,
-  streamingFile,
+  previewSession,
   genericResourceData,
+  previewContextKey,
 }: ResourceContentProps) {
-  const streamFileName = streamingFile?.fileName || 'file.md'
-  const streamingExtractedContent = useMemo(() => {
-    if (!streamingFile) return undefined
-    const extracted = extractFileContent(streamingFile.content)
-    return extracted.length > 0 ? extracted : undefined
-  }, [streamingFile])
+  const streamFileName = previewSession?.fileName || 'file.md'
   const syntheticFile = useMemo(() => {
     const ext = getFileExtension(streamFileName)
-    const type = ext === 'pptx' ? 'text/x-pptxgenjs' : getMimeTypeFromExtension(ext)
+    const SOURCE_MIME_MAP: Record<string, string> = {
+      pptx: 'text/x-pptxgenjs',
+      docx: 'text/x-docxjs',
+      pdf: 'text/x-pdflibjs',
+    }
+    const type = SOURCE_MIME_MAP[ext] ?? getMimeTypeFromExtension(ext)
     return {
       id: 'streaming-file',
       workspaceId,
@@ -105,16 +127,26 @@ export const ResourceContent = memo(function ResourceContent({
     }
   }, [workspaceId, streamFileName])
 
-  if (streamingFile && resource.id === 'streaming-file') {
+  const streamingFileMode: 'append' | 'replace' = 'replace'
+  const disableStreamingAutoScroll = previewSession?.operation === 'patch'
+  const rawPreviewText = previewSession?.previewText
+  const streamingPreviewText =
+    typeof rawPreviewText === 'string' && rawPreviewText.length > 0 ? rawPreviewText : undefined
+
+  if (previewSession && resource.id === 'streaming-file') {
     return (
       <div className='flex h-full flex-col overflow-hidden'>
-        {streamingExtractedContent !== undefined ? (
+        {streamingPreviewText !== undefined ? (
           <FileViewer
             file={syntheticFile}
             workspaceId={workspaceId}
             canEdit={false}
             previewMode={previewMode ?? 'preview'}
-            streamingContent={streamingExtractedContent}
+            streamingContent={streamingPreviewText}
+            streamingMode={streamingFileMode}
+            disableStreamingAutoScroll={disableStreamingAutoScroll}
+            previewContextKey={previewContextKey}
+            useCodeRendererForCodeFiles
           />
         ) : (
           <div className='flex h-full items-center justify-center'>
@@ -136,7 +168,12 @@ export const ResourceContent = memo(function ResourceContent({
           workspaceId={workspaceId}
           fileId={resource.id}
           previewMode={previewMode}
-          streamingContent={streamingExtractedContent}
+          streamingContent={
+            previewSession?.fileId === resource.id ? streamingPreviewText : undefined
+          }
+          streamingMode={streamingFileMode}
+          disableStreamingAutoScroll={disableStreamingAutoScroll}
+          previewContextKey={previewContextKey}
         />
       )
 
@@ -158,6 +195,9 @@ export const ResourceContent = memo(function ResourceContent({
     case 'folder':
       return <EmbeddedFolder key={resource.id} workspaceId={workspaceId} folderId={resource.id} />
 
+    case 'log':
+      return <EmbeddedLog key={resource.id} logId={resource.id} />
+
     case 'generic':
       return (
         <GenericResourceContent key={resource.id} data={genericResourceData ?? { entries: [] }} />
@@ -183,6 +223,8 @@ export function ResourceActions({ workspaceId, resource }: ResourceActionsProps)
       return (
         <EmbeddedKnowledgeBaseActions workspaceId={workspaceId} knowledgeBaseId={resource.id} />
       )
+    case 'log':
+      return <EmbeddedLogActions workspaceId={workspaceId} logId={resource.id} />
     case 'folder':
     case 'generic':
       return null
@@ -425,9 +467,20 @@ interface EmbeddedFileProps {
   fileId: string
   previewMode?: PreviewMode
   streamingContent?: string
+  streamingMode?: 'append' | 'replace'
+  disableStreamingAutoScroll?: boolean
+  previewContextKey?: string
 }
 
-function EmbeddedFile({ workspaceId, fileId, previewMode, streamingContent }: EmbeddedFileProps) {
+function EmbeddedFile({
+  workspaceId,
+  fileId,
+  previewMode,
+  streamingContent,
+  streamingMode,
+  disableStreamingAutoScroll = false,
+  previewContextKey,
+}: EmbeddedFileProps) {
   const { canEdit } = useUserPermissionsContext()
   const { data: files = [], isLoading, isFetching } = useWorkspaceFiles(workspaceId)
   const file = useMemo(() => files.find((f) => f.id === fileId), [files, fileId])
@@ -455,8 +508,12 @@ function EmbeddedFile({ workspaceId, fileId, previewMode, streamingContent }: Em
         file={file}
         workspaceId={workspaceId}
         canEdit={canEdit}
+        streamingMode={streamingMode}
         previewMode={previewMode}
         streamingContent={streamingContent}
+        disableStreamingAutoScroll={disableStreamingAutoScroll}
+        previewContextKey={previewContextKey}
+        useCodeRendererForCodeFiles
       />
     </div>
   )
@@ -528,15 +585,316 @@ function EmbeddedFolder({ workspaceId, folderId }: EmbeddedFolderProps) {
   )
 }
 
-function extractFileContent(raw: string): string {
-  const marker = '"content":'
-  const idx = raw.indexOf(marker)
-  if (idx === -1) return ''
-  let rest = raw.slice(idx + marker.length).trimStart()
-  if (rest.startsWith('"')) rest = rest.slice(1)
-  return rest
-    .replace(/\\n/g, '\n')
-    .replace(/\\t/g, '\t')
-    .replace(/\\"/g, '"')
-    .replace(/\\\\/g, '\\')
+interface EmbeddedLogProps {
+  logId: string
+}
+
+function EmbeddedLog({ logId }: EmbeddedLogProps) {
+  const { data: log, isLoading } = useLogDetail(logId)
+  const [isSnapshotOpen, setIsSnapshotOpen] = useState(false)
+
+  const logStatus = getDisplayStatus(log?.status)
+
+  const workflowOutput = useMemo(() => {
+    const executionData = log?.executionData as
+      | { finalOutput?: Record<string, unknown> }
+      | undefined
+    if (!executionData?.finalOutput) return null
+    return filterHiddenOutputKeys(executionData.finalOutput) as Record<string, unknown>
+  }, [log?.executionData])
+
+  const isWorkflowExecutionLog = useMemo(() => {
+    if (!log) return false
+    return (
+      (log.trigger === 'manual' && !!log.duration) ||
+      (log.executionData?.enhanced && log.executionData?.traceSpans)
+    )
+  }, [log])
+
+  const hasCostInfo = isWorkflowExecutionLog && log?.cost
+
+  const formattedTimestamp = useMemo(
+    () => (log ? formatDate(log.createdAt) : null),
+    [log?.createdAt]
+  )
+
+  if (isLoading) return LOADING_SKELETON
+
+  if (!log) {
+    return (
+      <div className='flex h-full flex-col items-center justify-center gap-3'>
+        <Library className='h-[32px] w-[32px] text-[var(--text-icon)]' />
+        <div className='flex flex-col items-center gap-1'>
+          <h2 className='font-medium text-[20px] text-[var(--text-primary)]'>Log not found</h2>
+          <p className='text-[var(--text-body)] text-small'>
+            This log may have been deleted or is no longer available
+          </p>
+        </div>
+      </div>
+    )
+  }
+
+  const workflowColor =
+    log.trigger === 'mothership'
+      ? '#ec4899'
+      : log.workflow?.color || (!log.workflowId ? 'var(--text-tertiary)' : undefined)
+
+  const totalToolCost = (() => {
+    const models = (log.cost as Record<string, unknown>)?.models as
+      | Record<string, { toolCost?: number }>
+      | undefined
+    return models ? Object.values(models).reduce((sum, m) => sum + (m?.toolCost || 0), 0) : 0
+  })()
+
+  return (
+    <div className='flex h-full flex-col overflow-y-auto'>
+      <div className='flex flex-col gap-2.5 p-4 pb-6'>
+        {/* Timestamp & Workflow Row */}
+        <div className='flex min-w-0 items-center gap-4 px-[1px]'>
+          <div className='flex w-[140px] flex-shrink-0 flex-col gap-2'>
+            <div className='font-medium text-[var(--text-tertiary)] text-caption'>Timestamp</div>
+            <div className='flex items-center gap-1.5'>
+              <span className='font-medium text-[var(--text-secondary)] text-sm'>
+                {formattedTimestamp?.compactDate || 'N/A'}
+              </span>
+              <span className='font-medium text-[var(--text-secondary)] text-sm'>
+                {formattedTimestamp?.compactTime || 'N/A'}
+              </span>
+            </div>
+          </div>
+          <div className='flex w-0 min-w-0 flex-1 flex-col gap-2'>
+            <div className='font-medium text-[var(--text-tertiary)] text-caption'>
+              {log.trigger === 'mothership' ? 'Job' : 'Workflow'}
+            </div>
+            <div className='flex min-w-0 items-center gap-2'>
+              <div
+                className='h-[10px] w-[10px] flex-shrink-0 rounded-[3px] border-[1.5px]'
+                style={{
+                  backgroundColor: workflowColor,
+                  borderColor: workflowColor ? workflowBorderColor(workflowColor) : undefined,
+                  backgroundClip: 'padding-box',
+                }}
+              />
+              <span className='min-w-0 flex-1 truncate font-medium text-[var(--text-secondary)] text-sm'>
+                {log.trigger === 'mothership'
+                  ? log.jobTitle || 'Untitled Job'
+                  : log.workflow?.name || (!log.workflowId ? 'Deleted Workflow' : 'Unknown')}
+              </span>
+            </div>
+          </div>
+        </div>
+
+        {/* Execution ID */}
+        {log.executionId && (
+          <div className='flex flex-col gap-1.5 rounded-md border border-[var(--border)] bg-[var(--surface-2)] px-2.5 py-2'>
+            <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+              Execution ID
+            </span>
+            <span className='truncate font-medium text-[var(--text-secondary)] text-sm'>
+              {log.executionId}
+            </span>
+          </div>
+        )}
+
+        {/* Details Section */}
+        <div className='-my-1 flex min-w-0 flex-col overflow-hidden'>
+          <div className='flex h-[48px] items-center justify-between border-[var(--border)] border-b p-2'>
+            <span className='font-medium text-[var(--text-tertiary)] text-caption'>Level</span>
+            <StatusBadge status={logStatus} />
+          </div>
+          <div className='flex h-[48px] items-center justify-between border-[var(--border)] border-b p-2'>
+            <span className='font-medium text-[var(--text-tertiary)] text-caption'>Trigger</span>
+            {log.trigger ? (
+              <TriggerBadge trigger={log.trigger} />
+            ) : (
+              <span className='font-medium text-[var(--text-secondary)] text-caption'>—</span>
+            )}
+          </div>
+          <div
+            className={cn(
+              'flex h-[48px] items-center justify-between border-b p-2',
+              log.deploymentVersion ? 'border-[var(--border)]' : 'border-transparent'
+            )}
+          >
+            <span className='font-medium text-[var(--text-tertiary)] text-caption'>Duration</span>
+            <span className='font-medium text-[var(--text-secondary)] text-small'>
+              {formatDuration(log.duration, { precision: 2 }) || '—'}
+            </span>
+          </div>
+          {log.deploymentVersion && (
+            <div className='flex h-[48px] items-center gap-2 p-2'>
+              <span className='flex-shrink-0 font-medium text-[var(--text-tertiary)] text-caption'>
+                Version
+              </span>
+              <div className='flex w-0 flex-1 justify-end'>
+                <span className='max-w-full truncate rounded-md bg-[var(--badge-success-bg)] px-[9px] py-0.5 font-medium text-[var(--badge-success-text)] text-caption'>
+                  {log.deploymentVersionName || `v${log.deploymentVersion}`}
+                </span>
+              </div>
+            </div>
+          )}
+        </div>
+
+        {/* Workflow State Snapshot */}
+        {isWorkflowExecutionLog && log.executionId && log.trigger !== 'mothership' && (
+          <div className='-mt-2 flex flex-col gap-1.5 rounded-md border border-[var(--border)] bg-[var(--surface-2)] px-2.5 py-2'>
+            <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+              Workflow State
+            </span>
+            <Button
+              variant='active'
+              onClick={() => setIsSnapshotOpen(true)}
+              className='flex w-full items-center justify-between px-2.5 py-1.5'
+            >
+              <span className='font-medium text-caption'>View Snapshot</span>
+              <Eye className='h-[14px] w-[14px]' />
+            </Button>
+          </div>
+        )}
+
+        {/* Workflow Output */}
+        {isWorkflowExecutionLog && workflowOutput && (
+          <div className='mt-1 flex flex-col gap-1.5 rounded-md border border-[var(--border)] bg-[var(--surface-2)] px-2.5 py-2 dark:bg-transparent'>
+            <span
+              className={cn(
+                'font-medium text-caption',
+                workflowOutput.error ? 'text-[var(--text-error)]' : 'text-[var(--text-tertiary)]'
+              )}
+            >
+              Workflow Output
+            </span>
+            <WorkflowOutputSection output={workflowOutput} />
+          </div>
+        )}
+
+        {/* Trace Spans */}
+        {isWorkflowExecutionLog && log.executionData?.traceSpans && (
+          <div className='mt-1 flex flex-col gap-1.5 rounded-md border border-[var(--border)] bg-[var(--surface-2)] px-2.5 py-2 dark:bg-transparent'>
+            <span className='font-medium text-[var(--text-tertiary)] text-caption'>Trace Span</span>
+            <TraceSpans traceSpans={log.executionData.traceSpans} />
+          </div>
+        )}
+
+        {/* Files */}
+        {log.files && log.files.length > 0 && <FileCards files={log.files} isExecutionFile />}
+
+        {/* Cost Breakdown */}
+        {hasCostInfo && (
+          <div className='flex flex-col gap-2'>
+            <span className='px-[1px] font-medium text-[var(--text-tertiary)] text-caption'>
+              Cost Breakdown
+            </span>
+            <div className='flex flex-col gap-1 rounded-md border border-[var(--border)]'>
+              <div className='flex flex-col gap-2.5 rounded-md p-2.5'>
+                <div className='flex items-center justify-between'>
+                  <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+                    Base Execution:
+                  </span>
+                  <span className='font-medium text-[var(--text-secondary)] text-caption'>
+                    {formatCost(BASE_EXECUTION_CHARGE)}
+                  </span>
+                </div>
+                <div className='flex items-center justify-between'>
+                  <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+                    Model Input:
+                  </span>
+                  <span className='font-medium text-[var(--text-secondary)] text-caption'>
+                    {formatCost(log.cost?.input || 0)}
+                  </span>
+                </div>
+                <div className='flex items-center justify-between'>
+                  <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+                    Model Output:
+                  </span>
+                  <span className='font-medium text-[var(--text-secondary)] text-caption'>
+                    {formatCost(log.cost?.output || 0)}
+                  </span>
+                </div>
+                {totalToolCost > 0 && (
+                  <div className='flex items-center justify-between'>
+                    <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+                      Tool Usage:
+                    </span>
+                    <span className='font-medium text-[var(--text-secondary)] text-caption'>
+                      {formatCost(totalToolCost)}
+                    </span>
+                  </div>
+                )}
+              </div>
+              <div className='border-[var(--border)] border-t' />
+              <div className='flex flex-col gap-2.5 rounded-md p-2.5'>
+                <div className='flex items-center justify-between'>
+                  <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+                    Total:
+                  </span>
+                  <span className='font-medium text-[var(--text-secondary)] text-caption'>
+                    {formatCost(log.cost?.total || 0)}
+                  </span>
+                </div>
+                <div className='flex items-center justify-between'>
+                  <span className='font-medium text-[var(--text-tertiary)] text-caption'>
+                    Tokens:
+                  </span>
+                  <span className='font-medium text-[var(--text-secondary)] text-caption'>
+                    {log.cost?.tokens?.input || log.cost?.tokens?.prompt || 0} in /{' '}
+                    {log.cost?.tokens?.output || log.cost?.tokens?.completion || 0} out
+                  </span>
+                </div>
+              </div>
+            </div>
+            <div className='flex items-center justify-center rounded-md bg-[var(--surface-2)] p-2 text-center'>
+              <p className='font-medium text-[var(--text-subtle)] text-xs'>
+                Total cost includes a base execution charge of {formatCost(BASE_EXECUTION_CHARGE)}{' '}
+                plus any model and tool usage costs.
+              </p>
+            </div>
+          </div>
+        )}
+      </div>
+
+      {/* Frozen Canvas Modal */}
+      {log.executionId && (
+        <ExecutionSnapshot
+          executionId={log.executionId}
+          traceSpans={log.executionData?.traceSpans}
+          isModal
+          isOpen={isSnapshotOpen}
+          onClose={() => setIsSnapshotOpen(false)}
+        />
+      )}
+    </div>
+  )
+}
+
+interface EmbeddedLogActionsProps {
+  workspaceId: string
+  logId: string
+}
+
+export function EmbeddedLogActions({ workspaceId, logId }: EmbeddedLogActionsProps) {
+  const router = useRouter()
+  const { data: log } = useLogDetail(logId)
+
+  const handleOpenInLogs = useCallback(() => {
+    const param = log?.executionId ? `?executionId=${log.executionId}` : ''
+    router.push(`/workspace/${workspaceId}/logs${param}`)
+  }, [router, workspaceId, log?.executionId])
+
+  return (
+    <Tooltip.Root>
+      <Tooltip.Trigger asChild>
+        <Button
+          variant='subtle'
+          onClick={handleOpenInLogs}
+          className={RESOURCE_TAB_ICON_BUTTON_CLASS}
+          aria-label='Open in logs'
+        >
+          <SquareArrowUpRight className={RESOURCE_TAB_ICON_CLASS} />
+        </Button>
+      </Tooltip.Trigger>
+      <Tooltip.Content side='bottom'>
+        <p>Open in logs</p>
+      </Tooltip.Content>
+    </Tooltip.Root>
+  )
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry/resource-registry.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry/resource-registry.tsx
index 59628a41237..b5ffc7d6f2e 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry/resource-registry.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry/resource-registry.tsx
@@ -8,6 +8,7 @@ import {
   Database,
   File as FileIcon,
   Folder as FolderIcon,
+  Library,
   Table as TableIcon,
   TerminalWindow,
 } from '@/components/emcn/icons'
@@ -20,6 +21,7 @@ import type {
   MothershipResourceType,
 } from '@/app/workspace/[workspaceId]/home/types'
 import { knowledgeKeys } from '@/hooks/queries/kb/knowledge'
+import { logKeys } from '@/hooks/queries/logs'
 import { tableKeys } from '@/hooks/queries/tables'
 import { taskKeys } from '@/hooks/queries/tasks'
 import { folderKeys } from '@/hooks/queries/utils/folder-keys'
@@ -163,6 +165,15 @@ export const RESOURCE_REGISTRY: Record<MothershipResourceType, ResourceTypeConfi
     ),
     renderDropdownItem: (props) => <IconDropdownItem {...props} icon={Blimp} />,
   },
+  log: {
+    type: 'log',
+    label: 'Logs',
+    icon: Library,
+    renderTabIcon: (_resource, className) => (
+      <Library className={cn(className, 'text-[var(--text-icon)]')} />
+    ),
+    renderDropdownItem: (props) => <IconDropdownItem {...props} icon={Library} />,
+  },
 } as const
 
 export const RESOURCE_TYPES = Object.values(RESOURCE_REGISTRY)
@@ -200,6 +211,10 @@ const RESOURCE_INVALIDATORS: Record<
   task: (qc, wId) => {
     qc.invalidateQueries({ queryKey: taskKeys.list(wId) })
   },
+  log: (qc, _wId, id) => {
+    qc.invalidateQueries({ queryKey: logKeys.details() })
+    qc.invalidateQueries({ queryKey: logKeys.detail(id) })
+  },
 }
 
 /**
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
index d94f9c966c9..68fb65c1ac9 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
@@ -9,8 +9,8 @@ import {
 } from 'react'
 import { Button, Tooltip } from '@/components/emcn'
 import { Columns3, Eye, PanelLeft, Pencil } from '@/components/emcn/icons'
-import { isEphemeralResource } from '@/lib/copilot/resource-extraction'
 import { SIM_RESOURCE_DRAG_TYPE, SIM_RESOURCES_DRAG_TYPE } from '@/lib/copilot/resource-types'
+import { isEphemeralResource } from '@/lib/copilot/resources/types'
 import { cn } from '@/lib/core/utils/cn'
 import type { PreviewMode } from '@/app/workspace/[workspaceId]/files/components/file-viewer'
 import { AddResourceDropdown } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/add-resource-dropdown'
@@ -38,7 +38,11 @@ import { useWorkspaceFiles } from '@/hooks/queries/workspace-files'
 const EDGE_ZONE = 40
 const SCROLL_SPEED = 8
 
-const ADD_RESOURCE_EXCLUDED_TYPES: readonly MothershipResourceType[] = ['folder', 'task'] as const
+const ADD_RESOURCE_EXCLUDED_TYPES: readonly MothershipResourceType[] = [
+  'folder',
+  'task',
+  'log',
+] as const
 
 /**
  * Returns the id of the nearest resource to `idx` that is in `filter`
@@ -70,14 +74,16 @@ function buildMultiDragImage(
 ): HTMLElement | null {
   if (!scrollNode || selected.length === 0) return null
   const container = document.createElement('div')
-  container.style.position = 'fixed'
-  container.style.top = '-10000px'
-  container.style.left = '-10000px'
-  container.style.display = 'flex'
-  container.style.alignItems = 'center'
-  container.style.gap = '6px'
-  container.style.padding = '4px'
-  container.style.pointerEvents = 'none'
+  Object.assign(container.style, {
+    position: 'fixed',
+    top: '-10000px',
+    left: '-10000px',
+    display: 'flex',
+    alignItems: 'center',
+    gap: '6px',
+    padding: '4px',
+    pointerEvents: 'none',
+  } satisfies Partial<CSSStyleDeclaration>)
   let appendedAny = false
   for (const r of selected) {
     const original = scrollNode.querySelector<HTMLElement>(
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
index d2d72250261..ccdebb09b68 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
@@ -1,6 +1,7 @@
 'use client'
 
-import { forwardRef, memo, useCallback, useState } from 'react'
+import { forwardRef, memo, useCallback, useEffect, useState } from 'react'
+import type { FilePreviewSession } from '@/lib/copilot/request/session'
 import { cn } from '@/lib/core/utils/cn'
 import { getFileExtension } from '@/lib/uploads/utils/file-utils'
 import type { PreviewMode } from '@/app/workspace/[workspaceId]/files/components/file-viewer'
@@ -19,37 +20,19 @@ const PREVIEW_CYCLE: Record<PreviewMode, PreviewMode> = {
   preview: 'editor',
 } as const
 
-function streamFileBasename(name: string): string {
-  const n = name.replace(/\\/g, '/').trim()
-  const parts = n.split('/').filter(Boolean)
-  return parts.length ? parts[parts.length - 1]! : n
-}
-
-function fileTitlesEquivalent(streamFileName: string, resourceTitle: string): boolean {
-  return streamFileBasename(streamFileName) === streamFileBasename(resourceTitle)
-}
-
 /**
- * Whether the active resource should show the in-progress file_write stream.
- * The synthetic `streaming-file` tab always shows it; a real file tab shows it when
- * the streamed `fileName` matches that resource (so users who stay on the open file see live text).
+ * Whether the active resource should show the in-progress file stream.
+ * The synthetic `streaming-file` tab always shows it; a real file tab only shows it
+ * when the streamed fileId matches that exact resource.
  */
-function streamReferencesFileId(raw: string, fileId: string): boolean {
-  if (!fileId) return false
-  const escaped = fileId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  return new RegExp(`"fileId"\\s*:\\s*"${escaped}"`).test(raw)
-}
-
 function shouldShowStreamingFilePanel(
-  streamingFile: { fileName: string; content: string } | null | undefined,
+  previewSession: FilePreviewSession | null | undefined,
   active: MothershipResource | null
 ): boolean {
-  if (!streamingFile || !active) return false
+  if (!previewSession || previewSession.status === 'complete' || !active) return false
   if (active.id === 'streaming-file') return true
   if (active.type !== 'file') return false
-  const fn = streamingFile.fileName.trim()
-  if (fn && fileTitlesEquivalent(fn, active.title)) return true
-  if (active.id && streamReferencesFileId(streamingFile.content, active.id)) return true
+  if (active.id && previewSession.fileId === active.id) return true
   return false
 }
 
@@ -65,7 +48,7 @@ interface MothershipViewProps {
   onCollapse: () => void
   isCollapsed: boolean
   className?: string
-  streamingFile?: { fileName: string; content: string } | null
+  previewSession?: FilePreviewSession | null
   genericResourceData?: GenericResourceData
 }
 
@@ -83,7 +66,7 @@ export const MothershipView = memo(
       onCollapse,
       isCollapsed,
       className,
-      streamingFile,
+      previewSession,
       genericResourceData,
     }: MothershipViewProps,
     ref
@@ -91,20 +74,21 @@ export const MothershipView = memo(
     const active = resources.find((r) => r.id === activeResourceId) ?? resources[0] ?? null
     const { canEdit } = useUserPermissionsContext()
 
-    const streamingForActive =
-      streamingFile && active && shouldShowStreamingFilePanel(streamingFile, active)
-        ? streamingFile
+    const previewForActive =
+      previewSession && active && shouldShowStreamingFilePanel(previewSession, active)
+        ? previewSession
         : undefined
 
     const [previewMode, setPreviewMode] = useState<PreviewMode>('preview')
     const [prevActiveId, setPrevActiveId] = useState<string | null | undefined>(active?.id)
     const handleCyclePreview = useCallback(() => setPreviewMode((m) => PREVIEW_CYCLE[m]), [])
 
-    // Reset preview mode to default when the active resource changes (guarded render-phase update)
-    if (active?.id !== prevActiveId) {
-      setPrevActiveId(active?.id)
-      setPreviewMode('preview')
-    }
+    useEffect(() => {
+      if (active?.id !== prevActiveId) {
+        setPrevActiveId(active?.id)
+        setPreviewMode('preview')
+      }
+    }, [active?.id, prevActiveId])
 
     const isActivePreviewable =
       canEdit &&
@@ -143,8 +127,9 @@ export const MothershipView = memo(
                 workspaceId={workspaceId}
                 resource={active}
                 previewMode={isActivePreviewable ? previewMode : undefined}
-                streamingFile={streamingForActive}
+                previewSession={previewForActive}
                 genericResourceData={active.type === 'generic' ? genericResourceData : undefined}
+                previewContextKey={chatId}
               />
             ) : (
               <div className='flex h-full items-center justify-center text-[var(--text-muted)] text-sm'>
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx
index 981dc9d0e58..3f180b10eb9 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx
@@ -104,7 +104,7 @@ interface UserInputProps {
   userId?: string
   onContextAdd?: (context: ChatContext) => void
   onContextRemove?: (context: ChatContext) => void
-  onEnterWhileEmpty?: () => boolean
+  onSendQueuedHead?: () => void
 }
 
 export function UserInput({
@@ -118,7 +118,7 @@ export function UserInput({
   userId,
   onContextAdd,
   onContextRemove,
-  onEnterWhileEmpty,
+  onSendQueuedHead,
 }: UserInputProps) {
   const { workspaceId } = useParams<{ workspaceId: string }>()
   const { navigateToSettings } = useSettingsNavigation()
@@ -266,8 +266,8 @@ export function UserInput({
   filesRef.current = files
   const contextRef = useRef(contextManagement)
   contextRef.current = contextManagement
-  const onEnterWhileEmptyRef = useRef(onEnterWhileEmpty)
-  onEnterWhileEmptyRef.current = onEnterWhileEmpty
+  const onSendQueuedHeadRef = useRef(onSendQueuedHead)
+  onSendQueuedHeadRef.current = onSendQueuedHead
   const isSendingRef = useRef(isSending)
   isSendingRef.current = isSending
 
@@ -445,6 +445,7 @@ export function UserInput({
     sttPrefixRef.current = ''
     resetTranscript()
     currentFiles.clearAttachedFiles()
+    prevSelectedContextsRef.current = []
     currentContext.clearContexts()
 
     if (textareaRef.current) {
@@ -456,8 +457,13 @@ export function UserInput({
     (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
       if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing) {
         e.preventDefault()
-        if (isSendingRef.current && !valueRef.current.trim()) {
-          onEnterWhileEmptyRef.current?.()
+        const hasSubmitPayload =
+          valueRef.current.trim().length > 0 ||
+          filesRef.current.attachedFiles.some((file) => !file.uploading && file.key)
+        if (!hasSubmitPayload) {
+          if (isSendingRef.current) {
+            onSendQueuedHeadRef.current?.()
+          }
           return
         }
         handleSubmit()
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx
index 3778f8fd1cf..d4a3ea7c7c1 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/user-message-content/user-message-content.tsx
@@ -65,14 +65,16 @@ function MentionHighlight({ context }: { context: ChatMessageContext }) {
 }
 
 export function UserMessageContent({ content, contexts }: UserMessageContentProps) {
+  const trimmed = content.trim()
+
   if (!contexts || contexts.length === 0) {
-    return <p className={USER_MESSAGE_CLASSES}>{content}</p>
+    return <p className={USER_MESSAGE_CLASSES}>{trimmed}</p>
   }
 
   const ranges = computeMentionRanges(content, contexts)
 
   if (ranges.length === 0) {
-    return <p className={USER_MESSAGE_CLASSES}>{content}</p>
+    return <p className={USER_MESSAGE_CLASSES}>{trimmed}</p>
   }
 
   const elements: React.ReactNode[] = []
diff --git a/apps/sim/app/workspace/[workspaceId]/home/home.tsx b/apps/sim/app/workspace/[workspaceId]/home/home.tsx
index 132d87b2a9e..229b161f727 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/home.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/home.tsx
@@ -17,7 +17,7 @@ import { useChatHistory, useMarkTaskRead } from '@/hooks/queries/tasks'
 import type { ChatContext } from '@/stores/panel'
 import { MothershipChat, MothershipView, TemplatePrompts, UserInput } from './components'
 import { getMothershipUseChatOptions, useChat, useMothershipResize } from './hooks'
-import type { FileAttachmentForApi, MothershipResourceType } from './types'
+import type { FileAttachmentForApi, MothershipResource, MothershipResourceType } from './types'
 
 const logger = createLogger('Home')
 
@@ -115,7 +115,7 @@ export function Home({ chatId }: HomeProps = {}) {
 
   const wasSendingRef = useRef(false)
 
-  useChatHistory(chatId)
+  const { isPending: isChatHistoryPending } = useChatHistory(chatId)
   const { mutate: markRead } = useMarkTaskRead(workspaceId)
 
   const { mothershipRef, handleResizePointerDown, clearWidth } = useMothershipResize()
@@ -157,7 +157,7 @@ export function Home({ chatId }: HomeProps = {}) {
     removeFromQueue,
     sendNow,
     editQueuedMessage,
-    streamingFile,
+    previewSession,
     genericResourceData,
   } = useChat(
     workspaceId,
@@ -201,8 +201,13 @@ export function Home({ chatId }: HomeProps = {}) {
 
   useEffect(() => {
     wasSendingRef.current = false
-    if (resolvedChatId) markRead(resolvedChatId)
-  }, [resolvedChatId, markRead])
+    if (resolvedChatId) {
+      markRead(resolvedChatId)
+    } else {
+      clearWidth()
+      setIsResourceCollapsed(true)
+    }
+  }, [resolvedChatId, markRead, clearWidth])
 
   useEffect(() => {
     if (wasSendingRef.current && !isSending && resolvedChatId) {
@@ -228,7 +233,7 @@ export function Home({ chatId }: HomeProps = {}) {
       workspace_id: workspaceId,
       view: 'mothership',
     })
-    stopGeneration()
+    void stopGeneration().catch(() => {})
   }, [stopGeneration, workspaceId])
 
   const handleSubmit = useCallback(
@@ -291,7 +296,7 @@ export function Home({ chatId }: HomeProps = {}) {
     [resolveResourceFromContext, addResource, handleResourceEvent]
   )
 
-  const handleContextRemove = useCallback(
+  const handleInitialContextRemove = useCallback(
     (context: ChatContext) => {
       const resolved = resolveResourceFromContext(context)
       if (resolved) removeResource(resolved.type, resolved.id)
@@ -299,7 +304,19 @@ export function Home({ chatId }: HomeProps = {}) {
     [resolveResourceFromContext, removeResource]
   )
 
+  const handleWorkspaceResourceSelect = useCallback(
+    (resource: MothershipResource) => {
+      const wasAdded = addResource(resource)
+      if (!wasAdded) {
+        setActiveResourceId(resource.id)
+      }
+      handleResourceEvent()
+    },
+    [addResource, handleResourceEvent, setActiveResourceId]
+  )
+
   const hasMessages = messages.length > 0
+  const showChatSkeleton = Boolean(chatId) && !hasMessages && isChatHistoryPending
 
   useEffect(() => {
     if (hasMessages) return
@@ -336,7 +353,7 @@ export function Home({ chatId }: HomeProps = {}) {
               onStopGeneration={handleStopGeneration}
               userId={session?.user?.id}
               onContextAdd={handleContextAdd}
-              onContextRemove={handleContextRemove}
+              onContextRemove={handleInitialContextRemove}
             />
           </div>
         </div>
@@ -358,6 +375,7 @@ export function Home({ chatId }: HomeProps = {}) {
           messages={messages}
           isSending={isSending}
           isReconnecting={isReconnecting}
+          isLoading={showChatSkeleton}
           onSubmit={handleSubmit}
           onStopGeneration={handleStopGeneration}
           messageQueue={messageQueue}
@@ -367,7 +385,7 @@ export function Home({ chatId }: HomeProps = {}) {
           userId={session?.user?.id}
           chatId={resolvedChatId}
           onContextAdd={handleContextAdd}
-          onContextRemove={handleContextRemove}
+          onWorkspaceResourceSelect={handleWorkspaceResourceSelect}
           editValue={editingInputValue}
           onEditValueConsumed={clearEditingValue}
           animateInput={isInputEntering}
@@ -401,8 +419,8 @@ export function Home({ chatId }: HomeProps = {}) {
         onReorderResources={reorderResources}
         onCollapse={collapseResource}
         isCollapsed={isResourceCollapsed}
-        streamingFile={streamingFile}
-        genericResourceData={genericResourceData}
+        previewSession={previewSession}
+        genericResourceData={genericResourceData ?? undefined}
         className={skipResourceTransition ? '!transition-none' : undefined}
       />
 
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
index ac5bf1ab167..57201306855 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
@@ -1,67 +1,126 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { createLogger } from '@sim/logger'
 import { useQueryClient } from '@tanstack/react-query'
-import { usePathname } from 'next/navigation'
+import { usePathname, useRouter } from 'next/navigation'
+import { toDisplayMessage } from '@/lib/copilot/chat/display-message'
+import type {
+  PersistedFileAttachment,
+  PersistedMessage,
+} from '@/lib/copilot/chat/persisted-message'
+import { MOTHERSHIP_CHAT_API_PATH } from '@/lib/copilot/constants'
+import type {
+  MothershipStreamV1ErrorPayload,
+  MothershipStreamV1ToolUI,
+} from '@/lib/copilot/generated/mothership-stream-v1'
 import {
-  cancelRunToolExecution,
-  executeRunToolOnClient,
-  markRunToolManuallyStopped,
-  reportManualRunToolStop,
-} from '@/lib/copilot/client-sse/run-tool-execution'
+  MothershipStreamV1EventType,
+  MothershipStreamV1ResourceOp,
+  MothershipStreamV1RunKind,
+  MothershipStreamV1SessionKind,
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1SpanPayloadKind,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
 import {
-  COPILOT_CHAT_API_PATH,
-  COPILOT_CHAT_STREAM_API_PATH,
-  MOTHERSHIP_CHAT_API_PATH,
-} from '@/lib/copilot/constants'
+  CrawlWebsite,
+  CreateFolder,
+  DeleteFolder,
+  DeleteWorkflow,
+  DeployApi,
+  DeployChat,
+  DeployMcp,
+  GetPageContents,
+  GetWorkflowLogs,
+  Glob,
+  Grep,
+  ManageCredential,
+  ManageCredentialOperation,
+  ManageCustomTool,
+  ManageCustomToolOperation,
+  ManageJob,
+  ManageJobOperation,
+  ManageMcpTool,
+  ManageMcpToolOperation,
+  ManageSkill,
+  ManageSkillOperation,
+  MoveFolder,
+  MoveWorkflow,
+  Read as ReadTool,
+  Redeploy,
+  RenameWorkflow,
+  RunFromBlock,
+  RunWorkflow,
+  RunWorkflowUntilBlock,
+  ScrapePage,
+  SearchOnline,
+  ToolSearchToolRegex,
+  WorkspaceFile,
+  WorkspaceFileOperation,
+} from '@/lib/copilot/generated/tool-catalog-v1'
+import { parsePersistedStreamEventEnvelopeJson } from '@/lib/copilot/request/session/contract'
+import {
+  type FilePreviewSession,
+  isFilePreviewSession,
+} from '@/lib/copilot/request/session/file-preview-session-contract'
+import { isStreamBatchEvent, type StreamBatchEvent } from '@/lib/copilot/request/session/types'
 import {
   extractResourcesFromToolResult,
-  isEphemeralResource,
   isResourceToolName,
-} from '@/lib/copilot/resource-extraction'
-import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resource-types'
-import { isWorkflowToolName } from '@/lib/copilot/workflow-tools'
+} from '@/lib/copilot/resources/extraction'
+import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resources/types'
+import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
+import {
+  bindRunToolToExecution,
+  cancelRunToolExecution,
+  executeRunToolOnClient,
+  markRunToolManuallyStopped,
+  reportManualRunToolStop,
+} from '@/lib/copilot/tools/client/run-tool-execution'
+import { isWorkflowToolName } from '@/lib/copilot/tools/workflow-tools'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getNextWorkflowColor } from '@/lib/workflows/colors'
 import { getQueryClient } from '@/app/_shell/providers/get-query-client'
 import { invalidateResourceQueries } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry'
-import type {
-  ChatMessage,
-  ChatMessageAttachment,
-  ContentBlock,
-  ContentBlockType,
-  FileAttachmentForApi,
-  GenericResourceData,
-  GenericResourceEntry,
-  MothershipResource,
-  MothershipResourceType,
-  QueuedMessage,
-  SSEPayload,
-  SSEPayloadData,
-  ToolCallStatus,
-} from '@/app/workspace/[workspaceId]/home/types'
+import {
+  buildCompletedPreviewSessions,
+  type FilePreviewSessionsState,
+  INITIAL_FILE_PREVIEW_SESSIONS_STATE,
+  reduceFilePreviewSessions,
+  useFilePreviewSessions,
+} from '@/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions'
 import { deploymentKeys } from '@/hooks/queries/deployments'
 import {
   fetchChatHistory,
-  type StreamSnapshot,
   type TaskChatHistory,
-  type TaskStoredContentBlock,
-  type TaskStoredFileAttachment,
-  type TaskStoredMessage,
-  type TaskStoredToolCall,
   taskKeys,
   useChatHistory,
 } from '@/hooks/queries/tasks'
 import { getFolderMap } from '@/hooks/queries/utils/folder-cache'
+import { folderKeys } from '@/hooks/queries/utils/folder-keys'
 import { invalidateWorkflowSelectors } from '@/hooks/queries/utils/invalidate-workflow-lists'
 import { getTopInsertionSortOrder } from '@/hooks/queries/utils/top-insertion-sort-order'
 import { getWorkflowById, getWorkflows } from '@/hooks/queries/utils/workflow-cache'
 import { workflowKeys } from '@/hooks/queries/workflows'
+import { workspaceFilesKeys } from '@/hooks/queries/workspace-files'
 import { useExecutionStream } from '@/hooks/use-execution-stream'
 import { useExecutionStore } from '@/stores/execution/store'
 import type { ChatContext } from '@/stores/panel'
-import { consolePersistence, useTerminalConsoleStore } from '@/stores/terminal'
+import { useTerminalConsoleStore } from '@/stores/terminal'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import type { WorkflowMetadata } from '@/stores/workflows/registry/types'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
+import type {
+  ChatMessage,
+  ContentBlock,
+  FileAttachmentForApi,
+  GenericResourceData,
+  MothershipResource,
+  MothershipResourceType,
+  QueuedMessage,
+} from '../types'
+
+const FILE_SUBAGENT_ID = 'file'
 
 export interface UseChatReturn {
   messages: ChatMessage[]
@@ -85,226 +144,465 @@ export interface UseChatReturn {
   removeFromQueue: (id: string) => void
   sendNow: (id: string) => Promise<void>
   editQueuedMessage: (id: string) => QueuedMessage | undefined
-  streamingFile: { fileName: string; content: string } | null
-  genericResourceData: GenericResourceData
+  previewSession: FilePreviewSession | null
+  genericResourceData: GenericResourceData | null
 }
 
-const STATE_TO_STATUS: Record<string, ToolCallStatus> = {
-  success: 'success',
-  error: 'error',
-  cancelled: 'cancelled',
-  rejected: 'error',
-  skipped: 'success',
-} as const
+const DEPLOY_TOOL_NAMES: Set<string> = new Set([
+  DeployApi.id,
+  DeployChat.id,
+  DeployMcp.id,
+  Redeploy.id,
+])
 
-const DEPLOY_TOOL_NAMES = new Set(['deploy_api', 'deploy_chat', 'deploy_mcp', 'redeploy'])
+const FOLDER_TOOL_NAMES: Set<string> = new Set([CreateFolder.id, DeleteFolder.id, MoveFolder.id])
+
+const WORKFLOW_MUTATION_TOOL_NAMES: Set<string> = new Set([
+  MoveWorkflow.id,
+  RenameWorkflow.id,
+  DeleteWorkflow.id,
+])
 const RECONNECT_TAIL_ERROR =
   'Live reconnect failed before the stream finished. The latest response may be incomplete.'
-const TERMINAL_STREAM_STATUSES = new Set(['complete', 'error', 'cancelled'])
 const MAX_RECONNECT_ATTEMPTS = 10
 const RECONNECT_BASE_DELAY_MS = 1000
 const RECONNECT_MAX_DELAY_MS = 30_000
 
-interface StreamEventEnvelope {
-  eventId: number
-  streamId: string
-  event: Record<string, unknown>
-}
+const logger = createLogger('useChat')
 
-interface StreamBatchResponse {
-  success: boolean
-  events: StreamEventEnvelope[]
-  status: string
-}
+type StreamPayload = Record<string, unknown>
+
+type QueueDispatchAction = { type: 'send_head'; epoch: number }
 
-interface StreamTerminationResult {
-  sawStreamError: boolean
-  sawDoneEvent: boolean
-  lastEventId: number
+type QueueDispatchActionInput = { type: 'send_head' }
+
+type ActiveTurn = {
+  userMessageId: string
+  assistantMessageId: string
+  optimisticUserMessage: ChatMessage
+  optimisticAssistantMessage: ChatMessage
 }
 
-interface StreamProcessingOptions {
-  expectedGen?: number
-  initialLastEventId?: number
-  preserveExistingState?: boolean
+function stringParam(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
 }
 
-interface AttachToStreamOptions {
-  streamId: string
-  assistantId: string
-  expectedGen: number
-  snapshot?: StreamSnapshot | null
-  initialLastEventId?: number
+function stringArrayParam(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value.filter((item): item is string => typeof item === 'string' && item.trim().length > 0)
 }
 
-interface AttachToStreamResult {
-  aborted: boolean
-  error: boolean
+function resolveWorkflowNameForDisplay(workflowId: unknown): string | undefined {
+  const id = stringParam(workflowId)
+  if (!id) return undefined
+  const workspaceId = useWorkflowRegistry.getState().hydration.workspaceId
+  if (!workspaceId) return undefined
+  return getWorkflowById(workspaceId, id)?.name
 }
 
-interface PendingStreamRecovery {
-  streamId: string
-  snapshot?: StreamSnapshot | null
+function resolveBlockNameForDisplay(blockId: unknown): string | undefined {
+  const id = stringParam(blockId)
+  if (!id) return undefined
+  return useWorkflowStore.getState().blocks[id]?.name
 }
 
-function isTerminalStreamStatus(status?: string | null): boolean {
-  return Boolean(status && TERMINAL_STREAM_STATUSES.has(status))
+function resolveWorkspaceFileDisplayTitle(
+  operation: unknown,
+  title: unknown,
+  targetFileName?: unknown
+): string | undefined {
+  const chunkTitle = stringParam(title)
+  const fileName = stringParam(targetFileName)
+  let verb = 'Writing'
+
+  switch (operation) {
+    case WorkspaceFileOperation.append:
+      verb = 'Adding'
+      break
+    case WorkspaceFileOperation.patch:
+      verb = 'Editing'
+      break
+    case WorkspaceFileOperation.update:
+      verb = 'Writing'
+      break
+  }
+
+  if (chunkTitle) return `${verb} ${chunkTitle}`
+  if (fileName) return `${verb} ${fileName}`
+  return undefined
 }
 
-function isActiveStreamConflictError(input: unknown): boolean {
-  if (typeof input !== 'string') return false
-  return input.includes('A response is already in progress for this chat')
+function resolveOperationDisplayTitle(
+  operation: unknown,
+  labels: Partial<Record<string, string>>,
+  fallback: string
+): string {
+  const label = typeof operation === 'string' ? labels[operation] : undefined
+  return label ?? fallback
 }
 
-/**
- * Extracts tool call IDs from snapshot events so that replayed client-executable
- * tool calls are not re-executed after a page refresh.
- */
-function extractToolCallIdsFromSnapshot(snapshot?: StreamSnapshot | null): Set<string> {
-  const ids = new Set<string>()
-  if (!snapshot?.events) return ids
-  for (const entry of snapshot.events) {
-    const event = entry.event
-    if (event.type === 'tool_call' && typeof event.toolCallId === 'string') {
-      ids.add(event.toolCallId)
-    }
+function resolveToolDisplayTitle(name: string, args?: Record<string, unknown>): string | undefined {
+  if (!args) return undefined
+
+  if (name === WorkspaceFile.id) {
+    const target = asPayloadRecord(args.target)
+    return resolveWorkspaceFileDisplayTitle(args.operation, args.title, target?.fileName)
+  }
+
+  if (name === SearchOnline.id) {
+    const toolTitle = stringParam(args.toolTitle)
+    return toolTitle ? `Searching online for ${toolTitle}` : 'Searching online'
+  }
+
+  if (name === Grep.id) {
+    const toolTitle = stringParam(args.toolTitle)
+    return toolTitle ? `Searching for ${toolTitle}` : 'Searching'
+  }
+
+  if (name === Glob.id) {
+    const toolTitle = stringParam(args.toolTitle)
+    return toolTitle ? `Finding ${toolTitle}` : 'Finding files'
+  }
+
+  if (name === ScrapePage.id) {
+    const url = stringParam(args.url)
+    return url ? `Scraping ${url}` : 'Scraping page'
+  }
+
+  if (name === CrawlWebsite.id) {
+    const url = stringParam(args.url)
+    return url ? `Crawling ${url}` : 'Crawling website'
+  }
+
+  if (name === GetPageContents.id) {
+    const urls = stringArrayParam(args.urls)
+    if (urls.length === 1) return `Getting ${urls[0]}`
+    if (urls.length > 1) return `Getting ${urls.length} pages`
+    return 'Getting page contents'
+  }
+
+  if (name === ManageCustomTool.id) {
+    return resolveOperationDisplayTitle(
+      args.operation,
+      {
+        [ManageCustomToolOperation.add]: 'Creating custom tool',
+        [ManageCustomToolOperation.edit]: 'Updating custom tool',
+        [ManageCustomToolOperation.delete]: 'Deleting custom tool',
+        [ManageCustomToolOperation.list]: 'Listing custom tools',
+      },
+      'Custom tool action'
+    )
+  }
+
+  if (name === ManageMcpTool.id) {
+    return resolveOperationDisplayTitle(
+      args.operation,
+      {
+        [ManageMcpToolOperation.add]: 'Creating MCP server',
+        [ManageMcpToolOperation.edit]: 'Updating MCP server',
+        [ManageMcpToolOperation.delete]: 'Deleting MCP server',
+        [ManageMcpToolOperation.list]: 'Listing MCP servers',
+      },
+      'MCP server action'
+    )
+  }
+
+  if (name === ManageSkill.id) {
+    return resolveOperationDisplayTitle(
+      args.operation,
+      {
+        [ManageSkillOperation.add]: 'Creating skill',
+        [ManageSkillOperation.edit]: 'Updating skill',
+        [ManageSkillOperation.delete]: 'Deleting skill',
+        [ManageSkillOperation.list]: 'Listing skills',
+      },
+      'Skill action'
+    )
   }
-  return ids
+
+  if (name === ManageJob.id) {
+    return resolveOperationDisplayTitle(
+      args.operation,
+      {
+        [ManageJobOperation.create]: 'Creating job',
+        [ManageJobOperation.get]: 'Getting job',
+        [ManageJobOperation.update]: 'Updating job',
+        [ManageJobOperation.delete]: 'Deleting job',
+        [ManageJobOperation.list]: 'Listing jobs',
+      },
+      'Job action'
+    )
+  }
+
+  if (name === ManageCredential.id) {
+    return resolveOperationDisplayTitle(
+      args.operation,
+      {
+        [ManageCredentialOperation.rename]: 'Renaming credential',
+        [ManageCredentialOperation.delete]: 'Deleting credential',
+      },
+      'Credential action'
+    )
+  }
+
+  if (name === RunWorkflow.id) {
+    const workflowName = resolveWorkflowNameForDisplay(args.workflowId)
+    return workflowName ? `Running ${workflowName}` : 'Running workflow'
+  }
+
+  if (name === RunFromBlock.id) {
+    const workflowName = resolveWorkflowNameForDisplay(args.workflowId)
+    const blockName = resolveBlockNameForDisplay(args.startBlockId)
+    if (workflowName && blockName) return `Running ${workflowName} from ${blockName}`
+    if (workflowName) return `Running ${workflowName}`
+    if (blockName) return `Running from ${blockName}`
+    return 'Running workflow'
+  }
+
+  if (name === RunWorkflowUntilBlock.id) {
+    const workflowName = resolveWorkflowNameForDisplay(args.workflowId)
+    const blockName = resolveBlockNameForDisplay(args.stopAfterBlockId)
+    if (workflowName && blockName) return `Running ${workflowName} until ${blockName}`
+    if (workflowName) return `Running ${workflowName}`
+    if (blockName) return `Running until ${blockName}`
+    return 'Running workflow'
+  }
+
+  if (name === GetWorkflowLogs.id) {
+    const workflowName = resolveWorkflowNameForDisplay(args.workflowId)
+    return workflowName ? `Getting logs for ${workflowName}` : 'Getting logs'
+  }
+
+  return undefined
 }
 
-function buildReplayStream(events: StreamEventEnvelope[]): ReadableStream<Uint8Array> {
-  const encoder = new TextEncoder()
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      if (events.length > 0) {
-        const payload = events
-          .map(
-            (entry) =>
-              `data: ${JSON.stringify({ ...entry.event, eventId: entry.eventId, streamId: entry.streamId })}\n\n`
-          )
-          .join('')
-        controller.enqueue(encoder.encode(payload))
-      }
-      controller.close()
-    },
-  })
+function decodeStreamingString(value: string): string {
+  return value
+    .replace(/\\u([0-9a-fA-F]{4})/g, (_: string, hex: string) =>
+      String.fromCharCode(Number.parseInt(hex, 16))
+    )
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\')
 }
 
-function mapStoredBlock(block: TaskStoredContentBlock): ContentBlock {
-  if (block.type === 'thinking') {
-    return {
-      type: 'text',
-      content: block.content ? `<thinking>${block.content}</thinking>` : '',
-    }
+function matchStreamingStringArg(streamingArgs: string, key: string): string | undefined {
+  const match = streamingArgs.match(new RegExp(`"${key}"\\s*:\\s*"([^"]*)"`, 'm'))
+  return match?.[1] ? decodeStreamingString(match[1]) : undefined
+}
+
+function resolveStreamingToolDisplayTitle(name: string, streamingArgs: string): string | undefined {
+  if (name === WorkspaceFile.id) {
+    return resolveWorkspaceFileDisplayTitle(
+      matchStreamingStringArg(streamingArgs, 'operation'),
+      matchStreamingStringArg(streamingArgs, 'title'),
+      matchStreamingStringArg(streamingArgs, 'fileName')
+    )
   }
 
-  const mapped: ContentBlock = {
-    type: block.type as ContentBlockType,
-    content: block.content,
+  if (name === SearchOnline.id) {
+    const toolTitle = matchStreamingStringArg(streamingArgs, 'toolTitle')
+    return toolTitle ? `Searching online for ${toolTitle}` : undefined
   }
 
-  if (block.type === 'tool_call' && block.toolCall) {
-    const resolvedStatus = STATE_TO_STATUS[block.toolCall.state ?? ''] ?? 'error'
-    mapped.toolCall = {
-      id: block.toolCall.id ?? '',
-      name: block.toolCall.name ?? 'unknown',
-      status: resolvedStatus,
-      displayTitle:
-        resolvedStatus === 'cancelled' ? 'Stopped by user' : block.toolCall.display?.text,
-      params: block.toolCall.params,
-      calledBy: block.toolCall.calledBy,
-      result: block.toolCall.result,
-    }
+  if (name === Grep.id) {
+    const toolTitle = matchStreamingStringArg(streamingArgs, 'toolTitle')
+    return toolTitle ? `Searching for ${toolTitle}` : undefined
   }
 
-  return mapped
-}
+  if (name === Glob.id) {
+    const toolTitle = matchStreamingStringArg(streamingArgs, 'toolTitle')
+    return toolTitle ? `Finding ${toolTitle}` : undefined
+  }
 
-function mapStoredToolCall(tc: TaskStoredToolCall): ContentBlock {
-  const resolvedStatus = (STATE_TO_STATUS[tc.status] ?? 'error') as ToolCallStatus
-  return {
-    type: 'tool_call',
-    toolCall: {
-      id: tc.id,
-      name: tc.name,
-      status: resolvedStatus,
-      displayTitle: resolvedStatus === 'cancelled' ? 'Stopped by user' : undefined,
-      params: tc.params,
-      result:
-        tc.result != null
-          ? {
-              success: tc.status === 'success',
-              output: tc.result,
-              error: tc.error,
-            }
-          : undefined,
-    },
+  if (name === ScrapePage.id) {
+    const url = matchStreamingStringArg(streamingArgs, 'url')
+    return url ? `Scraping ${url}` : undefined
   }
-}
 
-function toDisplayAttachment(f: TaskStoredFileAttachment): ChatMessageAttachment {
-  return {
-    id: f.id,
-    filename: f.filename,
-    media_type: f.media_type,
-    size: f.size,
-    previewUrl: f.media_type.startsWith('image/')
-      ? `/api/files/serve/${encodeURIComponent(f.key)}?context=mothership`
-      : undefined,
+  if (name === CrawlWebsite.id) {
+    const url = matchStreamingStringArg(streamingArgs, 'url')
+    return url ? `Crawling ${url}` : undefined
   }
-}
 
-function mapStoredMessage(msg: TaskStoredMessage): ChatMessage {
-  const mapped: ChatMessage = {
-    id: msg.id,
-    role: msg.role,
-    content: msg.content,
-    ...(msg.requestId ? { requestId: msg.requestId } : {}),
+  if (name === ManageCustomTool.id) {
+    return resolveOperationDisplayTitle(
+      matchStreamingStringArg(streamingArgs, 'operation'),
+      {
+        [ManageCustomToolOperation.add]: 'Creating custom tool',
+        [ManageCustomToolOperation.edit]: 'Updating custom tool',
+        [ManageCustomToolOperation.delete]: 'Deleting custom tool',
+        [ManageCustomToolOperation.list]: 'Listing custom tools',
+      },
+      'Custom tool action'
+    )
   }
 
-  const hasContentBlocks = Array.isArray(msg.contentBlocks) && msg.contentBlocks.length > 0
-  const hasToolCalls = Array.isArray(msg.toolCalls) && msg.toolCalls.length > 0
-  const contentBlocksHaveTools =
-    hasContentBlocks && msg.contentBlocks!.some((b) => b.type === 'tool_call')
+  if (name === ManageMcpTool.id) {
+    return resolveOperationDisplayTitle(
+      matchStreamingStringArg(streamingArgs, 'operation'),
+      {
+        [ManageMcpToolOperation.add]: 'Creating MCP server',
+        [ManageMcpToolOperation.edit]: 'Updating MCP server',
+        [ManageMcpToolOperation.delete]: 'Deleting MCP server',
+        [ManageMcpToolOperation.list]: 'Listing MCP servers',
+      },
+      'MCP server action'
+    )
+  }
 
-  if (hasContentBlocks && (!hasToolCalls || contentBlocksHaveTools)) {
-    const blocks = msg.contentBlocks!.map(mapStoredBlock)
-    const hasText = blocks.some((b) => b.type === 'text' && b.content?.trim())
-    if (!hasText && msg.content?.trim()) {
-      blocks.push({ type: 'text', content: msg.content })
-    }
-    mapped.contentBlocks = blocks
-  } else if (hasToolCalls) {
-    const blocks: ContentBlock[] = msg.toolCalls!.map(mapStoredToolCall)
-    if (msg.content?.trim()) {
-      blocks.push({ type: 'text', content: msg.content })
-    }
-    mapped.contentBlocks = blocks
+  if (name === ManageSkill.id) {
+    return resolveOperationDisplayTitle(
+      matchStreamingStringArg(streamingArgs, 'operation'),
+      {
+        [ManageSkillOperation.add]: 'Creating skill',
+        [ManageSkillOperation.edit]: 'Updating skill',
+        [ManageSkillOperation.delete]: 'Deleting skill',
+        [ManageSkillOperation.list]: 'Listing skills',
+      },
+      'Skill action'
+    )
   }
 
-  if (Array.isArray(msg.fileAttachments) && msg.fileAttachments.length > 0) {
-    mapped.attachments = msg.fileAttachments.map(toDisplayAttachment)
+  if (name === ManageJob.id) {
+    return resolveOperationDisplayTitle(
+      matchStreamingStringArg(streamingArgs, 'operation'),
+      {
+        [ManageJobOperation.create]: 'Creating job',
+        [ManageJobOperation.get]: 'Getting job',
+        [ManageJobOperation.update]: 'Updating job',
+        [ManageJobOperation.delete]: 'Deleting job',
+        [ManageJobOperation.list]: 'Listing jobs',
+      },
+      'Job action'
+    )
   }
 
-  if (Array.isArray(msg.contexts) && msg.contexts.length > 0) {
-    mapped.contexts = msg.contexts.map((c) => ({
-      kind: c.kind,
-      label: c.label,
-      ...(c.workflowId && { workflowId: c.workflowId }),
-      ...(c.knowledgeId && { knowledgeId: c.knowledgeId }),
-      ...(c.tableId && { tableId: c.tableId }),
-      ...(c.fileId && { fileId: c.fileId }),
-      ...(c.folderId && { folderId: c.folderId }),
-    }))
+  if (name === ManageCredential.id) {
+    return resolveOperationDisplayTitle(
+      matchStreamingStringArg(streamingArgs, 'operation'),
+      {
+        [ManageCredentialOperation.rename]: 'Renaming credential',
+        [ManageCredentialOperation.delete]: 'Deleting credential',
+      },
+      'Credential action'
+    )
   }
 
-  return mapped
+  return undefined
 }
 
-const logger = createLogger('useChat')
+type StreamToolUI = {
+  hidden?: boolean
+  title?: string
+  phaseLabel?: string
+  clientExecutable?: boolean
+}
+
+type StreamBatchResponse = {
+  success: boolean
+  events: StreamBatchEvent[]
+  previewSessions?: FilePreviewSession[]
+  status: string
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function parseStreamBatchResponse(value: unknown): StreamBatchResponse {
+  if (!isRecord(value)) {
+    throw new Error('Invalid stream batch response')
+  }
+
+  const rawEvents = Array.isArray(value.events) ? value.events : []
+  const events: StreamBatchEvent[] = []
+  for (const entry of rawEvents) {
+    if (!isStreamBatchEvent(entry)) {
+      throw new Error('Invalid stream batch event')
+    }
+    events.push(entry)
+  }
+
+  const rawPreviewSessions = Array.isArray(value.previewSessions)
+    ? value.previewSessions
+    : undefined
+  const previewSessions =
+    rawPreviewSessions?.map((session) => {
+      if (!isFilePreviewSession(session)) {
+        throw new Error('Invalid stream preview session')
+      }
+      return session
+    }) ?? undefined
+
+  return {
+    success: value.success === true,
+    events,
+    ...(previewSessions ? { previewSessions } : {}),
+    status: typeof value.status === 'string' ? value.status : 'unknown',
+  }
+}
+
+function buildChatHistoryHydrationKey(chatHistory: TaskChatHistory): string {
+  const resourceKey = chatHistory.resources
+    .map((resource) => `${resource.type}:${resource.id}:${resource.title}`)
+    .join('|')
+  const messageKey = chatHistory.messages.map((message) => message.id).join('|')
+  const streamSnapshot = chatHistory.streamSnapshot
+  const snapshotKey = streamSnapshot
+    ? [
+        streamSnapshot.status,
+        streamSnapshot.events.length,
+        streamSnapshot.events[streamSnapshot.events.length - 1]?.eventId ?? '',
+        streamSnapshot.previewSessions
+          .map(
+            (session) =>
+              `${session.id}:${session.previewVersion}:${session.status}:${session.updatedAt}`
+          )
+          .join('|'),
+      ].join('~')
+    : 'none'
+
+  return [
+    chatHistory.id,
+    chatHistory.activeStreamId ?? '',
+    messageKey,
+    resourceKey,
+    snapshotKey,
+  ].join('::')
+}
+
+const TERMINAL_STREAM_STATUSES = new Set(['complete', 'error', 'cancelled'])
+
+function isTerminalStreamStatus(status: string | null | undefined): boolean {
+  return TERMINAL_STREAM_STATUSES.has(status ?? '')
+}
+
+const sseEncoder = new TextEncoder()
+function buildReplayStream(events: StreamBatchEvent[]): ReadableStream<Uint8Array> {
+  return new ReadableStream({
+    start(controller) {
+      const payload = events.map((entry) => `data: ${JSON.stringify(entry.event)}\n\n`).join('')
+      controller.enqueue(sseEncoder.encode(payload))
+      controller.close()
+    },
+  })
+}
+
+function asPayloadRecord(value: unknown): StreamPayload | undefined {
+  return isRecord(value) ? value : undefined
+}
+
+function getToolUI(ui?: MothershipStreamV1ToolUI): StreamToolUI | undefined {
+  if (!ui) {
+    return undefined
+  }
 
-function getPayloadData(payload: SSEPayload): SSEPayloadData | undefined {
-  return typeof payload.data === 'object' ? payload.data : undefined
+  return {
+    ...(typeof ui.hidden === 'boolean' ? { hidden: ui.hidden } : {}),
+    ...(typeof ui.title === 'string' ? { title: ui.title } : {}),
+    ...(typeof ui.phaseLabel === 'string' ? { phaseLabel: ui.phaseLabel } : {}),
+    ...(typeof ui.clientExecutable === 'boolean' ? { clientExecutable: ui.clientExecutable } : {}),
+  }
 }
 
 /** Adds a workflow to the React Query cache with a top-insertion sort order if it doesn't already exist. */
@@ -399,7 +697,7 @@ export function getWorkflowCopilotUseChatOptions(
   > = {}
 ): UseChatOptions {
   return {
-    apiPath: COPILOT_CHAT_API_PATH,
+    apiPath: MOTHERSHIP_CHAT_API_PATH,
     stopPath: '/api/mothership/chat/stop',
     ...options,
   }
@@ -411,6 +709,7 @@ export function useChat(
   options?: UseChatOptions
 ): UseChatReturn {
   const pathname = usePathname()
+  const router = useRouter()
   const queryClient = useQueryClient()
   const [messages, setMessages] = useState<ChatMessage[]>([])
   const [isSending, setIsSending] = useState(false)
@@ -418,14 +717,17 @@ export function useChat(
   const [error, setError] = useState<string | null>(null)
   const [resolvedChatId, setResolvedChatId] = useState<string | undefined>(initialChatId)
   const [resources, setResources] = useState<MothershipResource[]>([])
-  const [activeResourceId, setActiveResourceId] = useState<string | null>(null)
-  const initialActiveResourceIdRef = useRef(options?.initialActiveResourceId)
+  const [activeResourceId, setActiveResourceId] = useState<string | null>(
+    options?.initialActiveResourceId ?? null
+  )
+  const [genericResourceData, setGenericResourceData] = useState<GenericResourceData | null>(null)
   const onResourceEventRef = useRef(options?.onResourceEvent)
   onResourceEventRef.current = options?.onResourceEvent
   const apiPathRef = useRef(options?.apiPath ?? MOTHERSHIP_CHAT_API_PATH)
   apiPathRef.current = options?.apiPath ?? MOTHERSHIP_CHAT_API_PATH
   const stopPathRef = useRef(options?.stopPath ?? '/api/mothership/chat/stop')
   stopPathRef.current = options?.stopPath ?? '/api/mothership/chat/stop'
+  const pendingStopPromiseRef = useRef<Promise<void> | null>(null)
   const workflowIdRef = useRef(options?.workflowId)
   workflowIdRef.current = options?.workflowId
   const onToolResultRef = useRef(options?.onToolResult)
@@ -434,6 +736,13 @@ export function useChat(
   onTitleUpdateRef.current = options?.onTitleUpdate
   const onStreamEndRef = useRef(options?.onStreamEnd)
   onStreamEndRef.current = options?.onStreamEnd
+
+  const clearQueueDispatchState = useCallback(() => {
+    queueDispatchEpochRef.current++
+    queueDispatchActionsRef.current = []
+    queuedMessageDispatchIdsRef.current.clear()
+    queueDispatchTaskRef.current = null
+  }, [])
   const resourcesRef = useRef(resources)
   resourcesRef.current = resources
 
@@ -449,46 +758,190 @@ export function useChat(
   const activeResourceIdRef = useRef(effectiveActiveResourceId)
   activeResourceIdRef.current = effectiveActiveResourceId
 
-  const [streamingFile, setStreamingFile] = useState<{
-    fileName: string
-    content: string
-  } | null>(null)
-  const streamingFileRef = useRef(streamingFile)
-  streamingFileRef.current = streamingFile
-
-  const [genericResourceData, setGenericResourceData] = useState<GenericResourceData>({
-    entries: [],
+  const {
+    previewSession,
+    previewSessionsById,
+    activePreviewSessionId,
+    hydratePreviewSessions,
+    upsertPreviewSession,
+    completePreviewSession,
+    removePreviewSession,
+    resetPreviewSessions,
+  } = useFilePreviewSessions()
+  const previewSessionRef = useRef(previewSession)
+  previewSessionRef.current = previewSession
+  const previewSessionsRef = useRef(previewSessionsById)
+  previewSessionsRef.current = previewSessionsById
+  const activePreviewSessionIdRef = useRef(activePreviewSessionId)
+  activePreviewSessionIdRef.current = activePreviewSessionId
+  const previewSessionsStateRef = useRef<FilePreviewSessionsState>({
+    activeSessionId: activePreviewSessionId,
+    sessions: previewSessionsById,
   })
-  const genericResourceDataRef = useRef<GenericResourceData>({ entries: [] })
+  previewSessionsStateRef.current = {
+    activeSessionId: activePreviewSessionId,
+    sessions: previewSessionsById,
+  }
+
+  const syncPreviewSessionRefs = useCallback((nextState: FilePreviewSessionsState) => {
+    previewSessionsStateRef.current = nextState
+    previewSessionsRef.current = nextState.sessions
+    activePreviewSessionIdRef.current = nextState.activeSessionId
+    previewSessionRef.current =
+      nextState.activeSessionId !== null
+        ? (nextState.sessions[nextState.activeSessionId] ?? null)
+        : null
+  }, [])
+
+  const applyPreviewSessionUpdate = useCallback(
+    (session: FilePreviewSession, options?: { activate?: boolean }) => {
+      const nextState = reduceFilePreviewSessions(previewSessionsStateRef.current, {
+        type: 'upsert',
+        session,
+        ...(options?.activate === false ? { activate: false } : {}),
+      })
+      syncPreviewSessionRefs(nextState)
+      upsertPreviewSession(session, options)
+      return nextState
+    },
+    [syncPreviewSessionRefs, upsertPreviewSession]
+  )
+
+  const applyCompletedPreviewSession = useCallback(
+    (session: FilePreviewSession) => {
+      const nextState = reduceFilePreviewSessions(previewSessionsStateRef.current, {
+        type: 'complete',
+        session,
+      })
+      syncPreviewSessionRefs(nextState)
+      completePreviewSession(session)
+      return nextState
+    },
+    [completePreviewSession, syncPreviewSessionRefs]
+  )
+
+  const reconcileTerminalPreviewSessions = useCallback(() => {
+    const completedAt = new Date().toISOString()
+    const completedSessions = buildCompletedPreviewSessions(
+      previewSessionsStateRef.current.sessions,
+      completedAt
+    )
+
+    for (const session of completedSessions) {
+      applyCompletedPreviewSession(session)
+    }
+  }, [applyCompletedPreviewSession])
+
+  const removePreviewSessionImmediate = useCallback(
+    (sessionId: string) => {
+      const nextState = reduceFilePreviewSessions(previewSessionsStateRef.current, {
+        type: 'remove',
+        sessionId,
+      })
+      syncPreviewSessionRefs(nextState)
+      removePreviewSession(sessionId)
+      return nextState
+    },
+    [removePreviewSession, syncPreviewSessionRefs]
+  )
 
   const [messageQueue, setMessageQueue] = useState<QueuedMessage[]>([])
   const messageQueueRef = useRef<QueuedMessage[]>([])
   messageQueueRef.current = messageQueue
-  const [pendingRecoveryMessage, setPendingRecoveryMessage] = useState<QueuedMessage | null>(null)
-  const pendingRecoveryMessageRef = useRef<QueuedMessage | null>(null)
-  pendingRecoveryMessageRef.current = pendingRecoveryMessage
+  const queuedMessageDispatchIdsRef = useRef<Set<string>>(new Set())
+  const queueDispatchActionsRef = useRef<QueueDispatchAction[]>([])
+  const queueDispatchTaskRef = useRef<Promise<void> | null>(null)
+  const queueDispatchEpochRef = useRef(0)
+  const queueDispatchLoopRef = useRef<() => Promise<void>>(async () => {})
+  const enqueueQueueDispatchRef = useRef<(action: QueueDispatchActionInput) => Promise<void>>(
+    async () => {}
+  )
 
-  const sendMessageRef = useRef<UseChatReturn['sendMessage']>(async () => {})
   const processSSEStreamRef = useRef<
     (
       reader: ReadableStreamDefaultReader<Uint8Array>,
       assistantId: string,
-      options?: StreamProcessingOptions
-    ) => Promise<StreamTerminationResult>
-  >(async () => ({
-    sawStreamError: false,
-    sawDoneEvent: false,
-    lastEventId: 0,
-  }))
-  const finalizeRef = useRef<(options?: { error?: boolean }) => void>(() => {})
-  const retryReconnectRef = useRef<
+      expectedGen?: number,
+      options?: { preserveExistingState?: boolean }
+    ) => Promise<{ sawStreamError: boolean; sawComplete: boolean }>
+  >(async () => ({ sawStreamError: false, sawComplete: false }))
+  const attachToExistingStreamRef = useRef<
     (opts: {
       streamId: string
       assistantId: string
-      gen: number
-      initialSnapshot?: StreamSnapshot | null
-    }) => Promise<boolean>
+      expectedGen: number
+      initialBatch?: StreamBatchResponse | null
+      afterCursor?: string
+    }) => Promise<{ error: boolean; aborted: boolean }>
+  >(async () => ({ error: false, aborted: true }))
+  const retryReconnectRef = useRef<
+    (opts: { streamId: string; assistantId: string; gen: number }) => Promise<boolean>
   >(async () => false)
+  const finalizeRef = useRef<(options?: { error?: boolean }) => void>(() => {})
+
+  const resetEphemeralPreviewState = useCallback(
+    (options?: { removeStreamingResource?: boolean }) => {
+      syncPreviewSessionRefs(INITIAL_FILE_PREVIEW_SESSIONS_STATE)
+      resetPreviewSessions()
+      if (options?.removeStreamingResource) {
+        setResources((current) => current.filter((resource) => resource.id !== 'streaming-file'))
+      }
+    },
+    [resetPreviewSessions, syncPreviewSessionRefs]
+  )
+
+  const syncPreviewResourceChrome = useCallback((session: FilePreviewSession) => {
+    if (session.targetKind === 'new_file') {
+      setResources((current) => {
+        const existing = current.find((resource) => resource.id === 'streaming-file')
+        if (existing) {
+          return current.map((resource) =>
+            resource.id === 'streaming-file'
+              ? { ...resource, title: session.fileName || 'Writing file...' }
+              : resource
+          )
+        }
+        return [
+          ...current,
+          {
+            type: 'file',
+            id: 'streaming-file',
+            title: session.fileName || 'Writing file...',
+          },
+        ]
+      })
+      setActiveResourceId('streaming-file')
+      return
+    }
+
+    if (session.fileId) {
+      setResources((current) => current.filter((resource) => resource.id !== 'streaming-file'))
+      setActiveResourceId(session.fileId)
+    }
+  }, [])
+
+  const seedPreviewSessions = useCallback(
+    (sessions: FilePreviewSession[]) => {
+      if (sessions.length === 0) {
+        return
+      }
+
+      const nextState = reduceFilePreviewSessions(previewSessionsStateRef.current, {
+        type: 'hydrate',
+        sessions,
+      })
+      syncPreviewSessionRefs(nextState)
+      hydratePreviewSessions(sessions)
+      const active =
+        nextState.activeSessionId !== null
+          ? (nextState.sessions[nextState.activeSessionId] ?? null)
+          : null
+      if (active) {
+        syncPreviewResourceChrome(active)
+      }
+    },
+    [hydratePreviewSessions, syncPreviewResourceChrome, syncPreviewSessionRefs]
+  )
 
   const abortControllerRef = useRef<AbortController | null>(null)
   const streamReaderRef = useRef<ReadableStreamDefaultReader<Uint8Array> | null>(null)
@@ -496,17 +949,102 @@ export function useChat(
   /** Panel/task selection — drives createNewChat + request chatId; may differ from chatIdRef while a stream is still finishing. */
   const selectedChatIdRef = useRef<string | undefined>(initialChatId)
   selectedChatIdRef.current = initialChatId
-  const appliedChatIdRef = useRef<string | undefined>(undefined)
-  const pendingUserMsgRef = useRef<{ id: string; content: string } | null>(null)
+  const appliedChatHistoryKeyRef = useRef<string | undefined>(undefined)
+  const activeTurnRef = useRef<ActiveTurn | null>(null)
+  const pendingUserMsgRef = useRef<PersistedMessage | null>(null)
   const streamIdRef = useRef<string | undefined>(undefined)
-  const lastEventIdRef = useRef(0)
+  const locallyTerminalStreamIdRef = useRef<string | undefined>(undefined)
+  const lastCursorRef = useRef('0')
   const sendingRef = useRef(false)
   const streamGenRef = useRef(0)
   const streamingContentRef = useRef('')
   const streamingBlocksRef = useRef<ContentBlock[]>([])
-  const clientExecutionStartedRef = useRef<Set<string>>(new Set())
+  const handledClientWorkflowToolIdsRef = useRef<Set<string>>(new Set())
+  const recoveringClientWorkflowToolIdsRef = useRef<Set<string>>(new Set())
   const executionStream = useExecutionStream()
   const isHomePage = pathname.endsWith('/home')
+  const wasHomePageRef = useRef(isHomePage)
+  const pendingHomeResetRef = useRef(false)
+
+  const setTransportIdle = useCallback(() => {
+    sendingRef.current = false
+    setIsSending(false)
+    setIsReconnecting(false)
+  }, [])
+
+  const setTransportStreaming = useCallback(() => {
+    sendingRef.current = true
+    setIsSending(true)
+    setIsReconnecting(false)
+  }, [])
+
+  const setTransportReconnecting = useCallback(() => {
+    sendingRef.current = true
+    setIsSending(true)
+    setIsReconnecting(true)
+  }, [])
+
+  const resetStreamingBuffers = useCallback(() => {
+    streamingContentRef.current = ''
+    streamingBlocksRef.current = []
+  }, [])
+
+  const clearActiveTurn = useCallback(() => {
+    activeTurnRef.current = null
+    pendingUserMsgRef.current = null
+    streamIdRef.current = undefined
+    lastCursorRef.current = '0'
+    resetStreamingBuffers()
+  }, [resetStreamingBuffers])
+
+  const resetHomeChatState = useCallback(() => {
+    streamGenRef.current++
+    chatIdRef.current = undefined
+    lastCursorRef.current = '0'
+    locallyTerminalStreamIdRef.current = undefined
+    clearActiveTurn()
+    setResolvedChatId(undefined)
+    appliedChatHistoryKeyRef.current = undefined
+    abortControllerRef.current = null
+    setMessages([])
+    setError(null)
+    setTransportIdle()
+    setResources([])
+    setActiveResourceId(null)
+    resetEphemeralPreviewState()
+    setMessageQueue([])
+    clearQueueDispatchState()
+  }, [clearActiveTurn, clearQueueDispatchState, resetEphemeralPreviewState, setTransportIdle])
+
+  const mergeServerMessagesWithActiveTurn = useCallback(
+    (serverMessages: ChatMessage[], previousMessages: ChatMessage[]) => {
+      const activeTurn = activeTurnRef.current
+      if (!activeTurn || !sendingRef.current) {
+        return serverMessages
+      }
+
+      const nextMessages = [...serverMessages]
+      const localStreamingUser =
+        previousMessages.find(
+          (message) => message.id === activeTurn.userMessageId && message.role === 'user'
+        ) ?? activeTurn.optimisticUserMessage
+      const localStreamingAssistant =
+        previousMessages.find(
+          (message) => message.id === activeTurn.assistantMessageId && message.role === 'assistant'
+        ) ?? activeTurn.optimisticAssistantMessage
+
+      if (!nextMessages.some((message) => message.id === localStreamingUser.id)) {
+        nextMessages.push(localStreamingUser)
+      }
+
+      if (!nextMessages.some((message) => message.id === localStreamingAssistant.id)) {
+        nextMessages.push(localStreamingAssistant)
+      }
+
+      return nextMessages
+    },
+    []
+  )
 
   const { data: chatHistory } = useChatHistory(initialChatId)
 
@@ -522,13 +1060,13 @@ export function useChat(
     })
     setActiveResourceId(resource.id)
 
-    if (isEphemeralResource(resource)) {
+    if (resource.id === 'streaming-file') {
       return true
     }
 
     const persistChatId = chatIdRef.current ?? selectedChatIdRef.current
     if (persistChatId) {
-      fetch('/api/copilot/chat/resources', {
+      fetch('/api/mothership/chat/resources', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ chatId: persistChatId, resource }),
@@ -541,391 +1079,296 @@ export function useChat(
 
   const removeResource = useCallback((resourceType: MothershipResourceType, resourceId: string) => {
     setResources((prev) => prev.filter((r) => !(r.type === resourceType && r.id === resourceId)))
+    setActiveResourceId((prev) => (prev === resourceId ? null : prev))
   }, [])
 
   const reorderResources = useCallback((newOrder: MothershipResource[]) => {
     setResources(newOrder)
   }, [])
 
-  useEffect(() => {
-    if (sendingRef.current) {
-      const streamOwnerId = chatIdRef.current
-      const navigatedToDifferentChat =
-        initialChatId !== streamOwnerId &&
-        (initialChatId !== undefined || streamOwnerId !== undefined)
+  const ensureWorkflowToolResource = useCallback(
+    (toolArgs: Record<string, unknown>): string | undefined => {
+      const targetWorkflowId =
+        typeof toolArgs.workflowId === 'string'
+          ? toolArgs.workflowId
+          : useWorkflowRegistry.getState().activeWorkflowId
 
-      if (navigatedToDifferentChat) {
-        const abandonedChatId = streamOwnerId
-        // Detach the current UI from the old stream without cancelling it on the server.
-        // Reopening that chat later will reconnect through the existing chatHistory flow.
-        streamGenRef.current++
-        abortControllerRef.current = null
-        sendingRef.current = false
-        setIsSending(false)
-        setIsReconnecting(false)
-        lastEventIdRef.current = 0
-        pendingRecoveryMessageRef.current = null
-        setPendingRecoveryMessage(null)
-        if (abandonedChatId) {
-          queryClient.invalidateQueries({ queryKey: taskKeys.detail(abandonedChatId) })
-        }
-      } else {
-        setResolvedChatId(initialChatId)
-        setMessageQueue([])
-        return
+      if (!targetWorkflowId) {
+        return undefined
       }
-    }
-    chatIdRef.current = initialChatId
-    setResolvedChatId(initialChatId)
-    appliedChatIdRef.current = undefined
-    setMessages([])
-    setError(null)
-    setIsSending(false)
-    setIsReconnecting(false)
-    setResources([])
-    setActiveResourceId(null)
-    setStreamingFile(null)
-    streamingFileRef.current = null
-    genericResourceDataRef.current = { entries: [] }
-    setGenericResourceData({ entries: [] })
-    setMessageQueue([])
-    lastEventIdRef.current = 0
-    clientExecutionStartedRef.current.clear()
-    pendingRecoveryMessageRef.current = null
-    setPendingRecoveryMessage(null)
-  }, [initialChatId, queryClient])
-
-  useEffect(() => {
-    if (workflowIdRef.current) return
-    if (!isHomePage || !chatIdRef.current) return
-    streamGenRef.current++
-    chatIdRef.current = undefined
-    setResolvedChatId(undefined)
-    appliedChatIdRef.current = undefined
-    abortControllerRef.current = null
-    sendingRef.current = false
-    setMessages([])
-    setError(null)
-    setIsSending(false)
-    setIsReconnecting(false)
-    setResources([])
-    setActiveResourceId(null)
-    setStreamingFile(null)
-    streamingFileRef.current = null
-    genericResourceDataRef.current = { entries: [] }
-    setGenericResourceData({ entries: [] })
-    setMessageQueue([])
-    lastEventIdRef.current = 0
-    clientExecutionStartedRef.current.clear()
-    pendingRecoveryMessageRef.current = null
-    setPendingRecoveryMessage(null)
-  }, [isHomePage])
-
-  const fetchStreamBatch = useCallback(
-    async (
-      streamId: string,
-      fromEventId: number,
-      signal?: AbortSignal
-    ): Promise<StreamBatchResponse> => {
-      const response = await fetch(
-        `${COPILOT_CHAT_STREAM_API_PATH}?streamId=${encodeURIComponent(streamId)}&from=${fromEventId}&batch=true`,
-        { signal }
-      )
 
-      if (!response.ok) {
-        throw new Error(`Stream resume batch failed: ${response.status}`)
+      const meta = getWorkflowById(workspaceId, targetWorkflowId)
+      const wasAdded = addResource({
+        type: 'workflow',
+        id: targetWorkflowId,
+        title: meta?.name ?? 'Workflow',
+      })
+      if (!wasAdded && activeResourceIdRef.current !== targetWorkflowId) {
+        setActiveResourceId(targetWorkflowId)
       }
+      onResourceEventRef.current?.()
 
-      return response.json()
+      return targetWorkflowId
     },
-    []
+    [addResource, workspaceId]
   )
 
-  const attachToExistingStream = useCallback(
-    async ({
-      streamId,
-      assistantId,
-      expectedGen,
-      snapshot,
-      initialLastEventId = 0,
-    }: AttachToStreamOptions): Promise<AttachToStreamResult> => {
-      let latestEventId = initialLastEventId
-      let seedEvents = snapshot?.events ?? []
-      let streamStatus = snapshot?.status ?? 'unknown'
-      let attachAttempt = 0
-
-      setIsSending(true)
-      setIsReconnecting(true)
-      setError(null)
-
-      logger.info('Attaching to existing stream', {
-        streamId,
-        expectedGen,
-        initialLastEventId,
-        seedEventCount: seedEvents.length,
-        streamStatus,
-      })
-
-      try {
-        while (streamGenRef.current === expectedGen) {
-          if (seedEvents.length > 0) {
-            const replayResult = await processSSEStreamRef.current(
-              buildReplayStream(seedEvents).getReader(),
-              assistantId,
-              {
-                expectedGen,
-                initialLastEventId: latestEventId,
-                preserveExistingState: true,
-              }
-            )
-            latestEventId = Math.max(
-              replayResult.lastEventId,
-              seedEvents[seedEvents.length - 1]?.eventId ?? latestEventId
-            )
-            lastEventIdRef.current = latestEventId
-            seedEvents = []
+  const startClientWorkflowTool = useCallback(
+    (toolCallId: string, toolName: string, toolArgs: Record<string, unknown>) => {
+      if (!isWorkflowToolName(toolName)) {
+        return
+      }
+      if (handledClientWorkflowToolIdsRef.current.has(toolCallId)) {
+        return
+      }
+      handledClientWorkflowToolIdsRef.current.add(toolCallId)
 
-            if (replayResult.sawStreamError) {
-              logger.warn('Replay stream ended with error event', { streamId, latestEventId })
-              return { aborted: false, error: true }
-            }
-          }
+      ensureWorkflowToolResource(toolArgs)
+      executeRunToolOnClient(toolCallId, toolName, toolArgs)
+    },
+    [ensureWorkflowToolResource]
+  )
 
-          if (isTerminalStreamStatus(streamStatus)) {
-            logger.info('Existing stream already reached terminal status', {
-              streamId,
-              latestEventId,
-              streamStatus,
-            })
-            if (streamStatus === 'error') {
-              setError(RECONNECT_TAIL_ERROR)
-            }
-            return { aborted: false, error: streamStatus === 'error' }
+  const recoverPendingClientWorkflowTools = useCallback(
+    async (nextMessages: ChatMessage[]) => {
+      for (const message of nextMessages) {
+        for (const block of message.contentBlocks ?? []) {
+          const toolCall = block.toolCall
+          if (!toolCall || !isWorkflowToolName(toolCall.name)) {
+            continue
           }
-
-          const activeAbortController = abortControllerRef.current
-          if (!activeAbortController) {
-            return { aborted: true, error: false }
+          if (toolCall.status !== 'executing') {
+            continue
           }
 
-          logger.info('Opening live stream tail', {
-            streamId,
-            fromEventId: latestEventId,
-            attempt: attachAttempt,
-          })
-
-          const sseRes = await fetch(
-            `${COPILOT_CHAT_STREAM_API_PATH}?streamId=${encodeURIComponent(streamId)}&from=${latestEventId}`,
-            { signal: activeAbortController.signal }
-          )
-          if (!sseRes.ok || !sseRes.body) {
-            throw new Error(RECONNECT_TAIL_ERROR)
+          if (
+            handledClientWorkflowToolIdsRef.current.has(toolCall.id) ||
+            recoveringClientWorkflowToolIdsRef.current.has(toolCall.id)
+          ) {
+            continue
           }
 
-          setIsReconnecting(false)
+          recoveringClientWorkflowToolIdsRef.current.add(toolCall.id)
 
-          const liveResult = await processSSEStreamRef.current(
-            sseRes.body.getReader(),
-            assistantId,
-            {
-              expectedGen,
-              initialLastEventId: latestEventId,
-              preserveExistingState: true,
+          try {
+            const toolArgs = toolCall.params ?? {}
+            const targetWorkflowId = ensureWorkflowToolResource(toolArgs)
+
+            if (targetWorkflowId) {
+              const rebound = await bindRunToolToExecution(toolCall.id, targetWorkflowId)
+              if (rebound) {
+                handledClientWorkflowToolIdsRef.current.add(toolCall.id)
+                continue
+              }
             }
-          )
-          latestEventId = Math.max(latestEventId, liveResult.lastEventId)
-          lastEventIdRef.current = latestEventId
-
-          if (liveResult.sawStreamError) {
-            logger.warn('Live stream tail ended with error event', { streamId, latestEventId })
-            return { aborted: false, error: true }
-          }
-
-          attachAttempt += 1
-          setIsReconnecting(true)
-
-          logger.warn('Live stream ended without terminal event, fetching replay batch', {
-            streamId,
-            latestEventId,
-            attempt: attachAttempt,
-          })
-
-          const batch = await fetchStreamBatch(
-            streamId,
-            latestEventId,
-            activeAbortController.signal
-          )
-          seedEvents = batch.events
-          streamStatus = batch.status
-
-          if (batch.events.length > 0) {
-            latestEventId = batch.events[batch.events.length - 1].eventId
-            lastEventIdRef.current = latestEventId
-          }
-
-          logger.info('Fetched replay batch after non-terminal stream close', {
-            streamId,
-            latestEventId,
-            streamStatus,
-            eventCount: batch.events.length,
-            attempt: attachAttempt,
-          })
 
-          if (batch.events.length === 0 && !isTerminalStreamStatus(batch.status)) {
-            logger.info('No new replay events yet; reopening active stream tail', {
-              streamId,
-              latestEventId,
-              streamStatus,
-              attempt: attachAttempt,
-            })
-            if (activeAbortController.signal.aborted || streamGenRef.current !== expectedGen) {
-              return { aborted: true, error: false }
-            }
+            startClientWorkflowTool(toolCall.id, toolCall.name, toolArgs)
+          } finally {
+            recoveringClientWorkflowToolIdsRef.current.delete(toolCall.id)
           }
         }
-
-        return { aborted: true, error: false }
-      } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') {
-          return { aborted: true, error: false }
-        }
-
-        logger.error('Failed to attach to existing stream, will throw for outer retry', {
-          streamId,
-          latestEventId,
-          error: err instanceof Error ? err.message : String(err),
-        })
-        throw err
-      } finally {
-        setIsReconnecting(false)
       }
     },
-    [fetchStreamBatch]
+    [ensureWorkflowToolResource, startClientWorkflowTool]
   )
 
-  const applyChatHistorySnapshot = useCallback(
-    (history: TaskChatHistory, options?: { preserveActiveStreamingMessage?: boolean }) => {
-      const preserveActiveStreamingMessage = options?.preserveActiveStreamingMessage ?? false
-      const activeStreamId = history.activeStreamId
-      appliedChatIdRef.current = history.id
-
-      const mappedMessages = history.messages.map(mapStoredMessage)
-      const shouldPreserveActiveStreamingMessage =
-        preserveActiveStreamingMessage &&
-        sendingRef.current &&
-        Boolean(activeStreamId) &&
-        activeStreamId === streamIdRef.current
-
-      if (shouldPreserveActiveStreamingMessage) {
-        setMessages((prev) => {
-          const localStreamingAssistant = prev[prev.length - 1]
-          if (localStreamingAssistant?.role !== 'assistant') {
-            return mappedMessages
-          }
-
-          const nextMessages =
-            mappedMessages[mappedMessages.length - 1]?.role === 'assistant'
-              ? mappedMessages.slice(0, -1)
-              : mappedMessages
+  useEffect(() => {
+    if (sendingRef.current) {
+      const streamOwnerId = chatIdRef.current
+      const navigatedToDifferentChat =
+        initialChatId !== streamOwnerId &&
+        (initialChatId !== undefined || streamOwnerId !== undefined)
 
-          return [...nextMessages, localStreamingAssistant]
-        })
+      if (navigatedToDifferentChat) {
+        const abandonedChatId = streamOwnerId
+        // Detach the current UI from the old stream without cancelling it on the server.
+        // Reopening that chat later will reconnect through the existing chatHistory flow.
+        streamGenRef.current++
+        abortControllerRef.current = null
+        clearActiveTurn()
+        setTransportIdle()
+        if (abandonedChatId) {
+          queryClient.invalidateQueries({ queryKey: taskKeys.detail(abandonedChatId) })
+        }
       } else {
-        setMessages(mappedMessages)
+        setResolvedChatId(initialChatId)
+        return
       }
+    }
+    chatIdRef.current = initialChatId
+    lastCursorRef.current = '0'
+    locallyTerminalStreamIdRef.current = undefined
+    clearActiveTurn()
+    setResolvedChatId(initialChatId)
+    appliedChatHistoryKeyRef.current = undefined
+    setMessages([])
+    setError(null)
+    setTransportIdle()
+    setResources([])
+    setActiveResourceId(null)
+    resetEphemeralPreviewState()
+    setMessageQueue([])
+    clearQueueDispatchState()
+  }, [
+    initialChatId,
+    queryClient,
+    resetEphemeralPreviewState,
+    clearQueueDispatchState,
+    clearActiveTurn,
+    setTransportIdle,
+  ])
 
-      if (history.resources.some((r) => r.id === 'streaming-file')) {
-        fetch('/api/copilot/chat/resources', {
-          method: 'DELETE',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            chatId: history.id,
-            resourceType: 'file',
-            resourceId: 'streaming-file',
-          }),
-        }).catch(() => {})
-      }
+  useEffect(() => {
+    const wasHomePage = wasHomePageRef.current
+    wasHomePageRef.current = isHomePage
 
-      const persistedResources = history.resources.filter((r) => r.id !== 'streaming-file')
-      if (persistedResources.length > 0) {
-        setResources(persistedResources)
-        const initialId = initialActiveResourceIdRef.current
-        const restoredId =
-          initialId && persistedResources.some((r) => r.id === initialId)
-            ? initialId
-            : persistedResources[persistedResources.length - 1].id
-        setActiveResourceId(restoredId)
-
-        for (const resource of persistedResources) {
-          if (resource.type !== 'workflow') continue
-          ensureWorkflowInRegistry(resource.id, resource.title, workspaceId)
-        }
-      } else if (history.resources.some((r) => r.id === 'streaming-file')) {
-        setResources([])
-        setActiveResourceId(null)
-      }
-    },
-    [workspaceId]
-  )
+    if (!isHomePage) {
+      pendingHomeResetRef.current = false
+      return
+    }
+    if (workflowIdRef.current || !chatIdRef.current) return
 
-  const preparePendingStreamRecovery = useCallback(
-    async (chatId: string): Promise<PendingStreamRecovery | null> => {
-      const latestHistory = await fetchChatHistory(chatId)
-      queryClient.setQueryData(taskKeys.detail(chatId), latestHistory)
-      applyChatHistorySnapshot(latestHistory)
+    const shouldHandleHomeReset = pendingHomeResetRef.current || !wasHomePage
+    if (!shouldHandleHomeReset) return
 
-      if (!latestHistory.activeStreamId) {
-        return null
-      }
+    const hasActiveTransport =
+      isSending ||
+      sendingRef.current ||
+      isReconnecting ||
+      abortControllerRef.current !== null ||
+      streamReaderRef.current !== null
 
-      return {
-        streamId: latestHistory.activeStreamId,
-        snapshot: latestHistory.streamSnapshot,
-      }
-    },
-    [applyChatHistorySnapshot, queryClient]
-  )
+    if (hasActiveTransport) {
+      pendingHomeResetRef.current = true
+      return
+    }
+
+    pendingHomeResetRef.current = false
+    resetHomeChatState()
+  }, [isHomePage, isReconnecting, isSending, resetHomeChatState])
 
   useEffect(() => {
     if (!chatHistory) return
 
+    const hydrationKey = buildChatHistoryHydrationKey(chatHistory)
+    if (appliedChatHistoryKeyRef.current === hydrationKey) return
+
     const activeStreamId = chatHistory.activeStreamId
-    const snapshot = chatHistory.streamSnapshot
-    const isNewChat = appliedChatIdRef.current !== chatHistory.id
+    appliedChatHistoryKeyRef.current = hydrationKey
+    const mappedMessages = chatHistory.messages.map(toDisplayMessage)
+    const snapshotEvents = Array.isArray(chatHistory.streamSnapshot?.events)
+      ? chatHistory.streamSnapshot.events
+      : []
+    const snapshotHasCompleteEvent = snapshotEvents.some(
+      (entry) => entry?.event?.type === MothershipStreamV1EventType.complete
+    )
+    const shouldReconnectActiveStream =
+      Boolean(activeStreamId) &&
+      !sendingRef.current &&
+      activeStreamId !== locallyTerminalStreamIdRef.current &&
+      !isTerminalStreamStatus(chatHistory.streamSnapshot?.status) &&
+      !snapshotHasCompleteEvent
+
+    if (!activeStreamId && locallyTerminalStreamIdRef.current) {
+      locallyTerminalStreamIdRef.current = undefined
+    }
+    const shouldPreserveLocalActiveTurn = sendingRef.current && activeTurnRef.current !== null
 
-    if (isNewChat) {
-      applyChatHistorySnapshot(chatHistory, { preserveActiveStreamingMessage: true })
-    } else if (!activeStreamId || sendingRef.current) {
-      return
+    if (shouldPreserveLocalActiveTurn) {
+      setMessages((prev) => mergeServerMessagesWithActiveTurn(mappedMessages, prev))
+    } else {
+      setMessages(mappedMessages)
+    }
+
+    void recoverPendingClientWorkflowTools(mappedMessages)
+
+    if (chatHistory.resources.some((r) => r.id === 'streaming-file')) {
+      fetch('/api/mothership/chat/resources', {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          chatId: chatHistory.id,
+          resourceType: 'file',
+          resourceId: 'streaming-file',
+        }),
+      }).catch(() => {})
+    }
+
+    const persistedResources = chatHistory.resources.filter((r) => r.id !== 'streaming-file')
+    if (persistedResources.length > 0) {
+      setResources(persistedResources)
+      setActiveResourceId(persistedResources[persistedResources.length - 1].id)
+
+      for (const resource of persistedResources) {
+        if (resource.type !== 'workflow') continue
+        ensureWorkflowInRegistry(resource.id, resource.title, workspaceId)
+      }
+    } else if (chatHistory.resources.some((r) => r.id === 'streaming-file')) {
+      setResources([])
+      setActiveResourceId(null)
+    }
+
+    const snapshotPreviewSessions = Array.isArray(chatHistory.streamSnapshot?.previewSessions)
+      ? (chatHistory.streamSnapshot.previewSessions as FilePreviewSession[])
+      : []
+    if (snapshotPreviewSessions.length > 0) {
+      seedPreviewSessions(snapshotPreviewSessions)
     }
 
-    if (activeStreamId && !sendingRef.current) {
+    if (shouldReconnectActiveStream && activeStreamId) {
       const gen = ++streamGenRef.current
       const abortController = new AbortController()
       abortControllerRef.current = abortController
       streamIdRef.current = activeStreamId
-      lastEventIdRef.current = snapshot?.events?.[snapshot.events.length - 1]?.eventId ?? 0
-      sendingRef.current = true
-      streamingContentRef.current = ''
-      streamingBlocksRef.current = []
-      clientExecutionStartedRef.current = extractToolCallIdsFromSnapshot(snapshot)
+      lastCursorRef.current = '0'
+      setTransportReconnecting()
 
       const assistantId = generateId()
 
       const reconnect = async () => {
-        const succeeded = await retryReconnectRef.current({
-          streamId: activeStreamId,
-          assistantId,
-          gen,
-          initialSnapshot: snapshot,
-        })
+        const initialSnapshot = chatHistory.streamSnapshot
+        const snapshotEvents = Array.isArray(initialSnapshot?.events)
+          ? (initialSnapshot.events as StreamBatchEvent[])
+          : []
+
+        const reconnectResult =
+          snapshotEvents.length > 0
+            ? await attachToExistingStreamRef.current({
+                streamId: activeStreamId,
+                assistantId,
+                expectedGen: gen,
+                initialBatch: {
+                  success: true,
+                  events: snapshotEvents,
+                  previewSessions: snapshotPreviewSessions,
+                  status: initialSnapshot?.status ?? 'unknown',
+                },
+                afterCursor: String(snapshotEvents[snapshotEvents.length - 1]?.eventId ?? '0'),
+              })
+            : null
+
+        const succeeded =
+          reconnectResult !== null
+            ? !reconnectResult.error || reconnectResult.aborted
+            : await retryReconnectRef.current({
+                streamId: activeStreamId,
+                assistantId,
+                gen,
+              })
+        if (succeeded && streamGenRef.current === gen && sendingRef.current) {
+          finalizeRef.current()
+          return
+        }
+        if (succeeded && streamGenRef.current === gen) {
+          setTransportIdle()
+          abortControllerRef.current = null
+          return
+        }
         if (!succeeded && streamGenRef.current === gen) {
           try {
             finalizeRef.current({ error: true })
           } catch {
-            sendingRef.current = false
-            setIsSending(false)
-            setIsReconnecting(false)
+            setTransportIdle()
             abortControllerRef.current = null
             setError('Failed to reconnect to the active stream')
           }
@@ -933,51 +1376,68 @@ export function useChat(
       }
       reconnect()
     }
-  }, [applyChatHistorySnapshot, chatHistory, queryClient])
+  }, [
+    chatHistory,
+    workspaceId,
+    queryClient,
+    recoverPendingClientWorkflowTools,
+    seedPreviewSessions,
+    mergeServerMessagesWithActiveTurn,
+    setTransportIdle,
+    setTransportReconnecting,
+  ])
 
   const processSSEStream = useCallback(
     async (
       reader: ReadableStreamDefaultReader<Uint8Array>,
       assistantId: string,
-      options?: StreamProcessingOptions
+      expectedGen?: number,
+      options?: { preserveExistingState?: boolean }
     ) => {
-      const { expectedGen, initialLastEventId = 0, preserveExistingState = false } = options ?? {}
       const decoder = new TextDecoder()
       streamReaderRef.current = reader
       let buffer = ''
-      const blocks: ContentBlock[] = preserveExistingState ? [...streamingBlocksRef.current] : []
+
+      const preserveState = options?.preserveExistingState === true
+      const blocks: ContentBlock[] = preserveState ? [...streamingBlocksRef.current] : []
       const toolMap = new Map<string, number>()
       const toolArgsMap = new Map<string, Record<string, unknown>>()
-      // Maps toolCallId → index in genericResourceDataRef.current.entries for fast lookup
-      const genericEntryMap = new Map<string, number>()
-      if (preserveExistingState) {
-        for (const [idx, entry] of genericResourceDataRef.current.entries.entries()) {
-          genericEntryMap.set(entry.toolCallId, idx)
+
+      if (preserveState) {
+        for (let i = 0; i < blocks.length; i++) {
+          const tc = blocks[i].toolCall
+          if (tc) {
+            toolMap.set(tc.id, i)
+            if (tc.params) toolArgsMap.set(tc.id, tc.params)
+          }
         }
       }
-      const clientExecutionStarted = clientExecutionStartedRef.current
+
       let activeSubagent: string | undefined
+      let activeSubagentParentToolCallId: string | undefined
       let activeCompactionId: string | undefined
-      let runningText = preserveExistingState ? streamingContentRef.current : ''
+
+      if (preserveState) {
+        for (let i = blocks.length - 1; i >= 0; i--) {
+          if (blocks[i].type === 'subagent' && blocks[i].content) {
+            activeSubagent = blocks[i].content
+            break
+          }
+          if (blocks[i].type === 'subagent_end') {
+            break
+          }
+        }
+      }
+
+      let runningText = preserveState ? streamingContentRef.current || '' : ''
       let lastContentSource: 'main' | 'subagent' | null = null
       let streamRequestId: string | undefined
-      let lastEventId = initialLastEventId
-      let sawDoneEvent = false
 
-      if (!preserveExistingState) {
+      if (!preserveState) {
         streamingContentRef.current = ''
         streamingBlocksRef.current = []
       }
 
-      for (const [index, block] of blocks.entries()) {
-        if (block.type === 'tool_call' && block.toolCall?.id) {
-          toolMap.set(block.toolCall.id, index)
-          if (block.toolCall.params) {
-            toolArgsMap.set(block.toolCall.id, block.toolCall.params)
-          }
-        }
-      }
-
       const ensureTextBlock = (): ContentBlock => {
         const last = blocks[blocks.length - 1]
         if (last?.type === 'text' && last.subagent === activeSubagent) return last
@@ -997,14 +1457,14 @@ export function useChat(
         flush()
       }
 
-      const buildInlineErrorTag = (payload: SSEPayload) => {
-        const data = getPayloadData(payload) as Record<string, unknown> | undefined
+      const buildInlineErrorTag = (payload: MothershipStreamV1ErrorPayload) => {
         const message =
-          (data?.displayMessage as string | undefined) ||
-          payload.error ||
+          (typeof payload.displayMessage === 'string' ? payload.displayMessage : undefined) ||
+          (typeof payload.message === 'string' ? payload.message : undefined) ||
+          (typeof payload.error === 'string' ? payload.error : undefined) ||
           'An unexpected error occurred'
-        const provider = (data?.provider as string | undefined) || undefined
-        const code = (data?.code as string | undefined) || undefined
+        const provider = typeof payload.provider === 'string' ? payload.provider : undefined
+        const code = typeof payload.code === 'string' ? payload.code : undefined
         return `<mothership-error>${JSON.stringify({
           message,
           ...(code ? { code } : {}),
@@ -1014,6 +1474,8 @@ export function useChat(
 
       const isStale = () => expectedGen !== undefined && streamGenRef.current !== expectedGen
       let sawStreamError = false
+      let sawCompleteEvent = false
+      let scheduledTextFlushFrame: number | null = null
 
       const flush = () => {
         if (isStale()) return
@@ -1036,504 +1498,550 @@ export function useChat(
         })
       }
 
-      const appendGenericEntry = (entry: GenericResourceEntry): number => {
-        const entries = [...genericResourceDataRef.current.entries, entry]
-        genericResourceDataRef.current.entries = entries
-        setGenericResourceData({ entries })
-        return entries.length - 1
-      }
-
-      const updateGenericEntry = (
-        entryIdx: number,
-        changes: Partial<GenericResourceEntry>
-      ): void => {
-        const entries = genericResourceDataRef.current.entries.slice()
-        entries[entryIdx] = { ...entries[entryIdx], ...changes }
-        genericResourceDataRef.current.entries = entries
-        setGenericResourceData({ entries })
+      const flushText = () => {
+        if (isStale()) return
+        if (scheduledTextFlushFrame !== null) return
+        if (typeof window === 'undefined' || typeof window.requestAnimationFrame !== 'function') {
+          flush()
+          return
+        }
+        scheduledTextFlushFrame = window.requestAnimationFrame(() => {
+          scheduledTextFlushFrame = null
+          flush()
+        })
       }
 
       try {
-        while (true) {
-          const { done, value } = await reader.read()
-          if (done) break
-          if (isStale()) continue
-
-          buffer += decoder.decode(value, { stream: true })
-          const lines = buffer.split('\n')
-          buffer = lines.pop() || ''
-
-          for (const line of lines) {
-            if (isStale()) break
-            if (!line.startsWith('data: ')) continue
-            const raw = line.slice(6)
-
-            let parsed: SSEPayload
-            try {
-              parsed = JSON.parse(raw)
-            } catch {
+        const pendingLines: string[] = []
+
+        readLoop: while (true) {
+          if (pendingLines.length === 0) {
+            const { done, value } = await reader.read()
+            if (done) break
+            if (isStale()) continue
+
+            buffer += decoder.decode(value, { stream: true })
+            const lines = buffer.split('\n')
+            buffer = lines.pop() || ''
+            pendingLines.push(...lines)
+            if (pendingLines.length === 0) {
               continue
             }
+          }
 
-            if (typeof (parsed as SSEPayload & { eventId?: unknown }).eventId === 'number') {
-              lastEventId = Math.max(
-                lastEventId,
-                (parsed as SSEPayload & { eventId: number }).eventId
-              )
-              lastEventIdRef.current = lastEventId
-            }
+          const line = pendingLines.shift()
+          if (line === undefined) {
+            continue
+          }
+          if (isStale()) {
+            pendingLines.length = 0
+            continue
+          }
+          if (!line.startsWith('data: ')) continue
+          const raw = line.slice(6)
+
+          const parsedResult = parsePersistedStreamEventEnvelopeJson(raw)
+          if (!parsedResult.ok) {
+            logger.warn('Failed to parse chat SSE event', {
+              reason: parsedResult.reason,
+              message: parsedResult.message,
+              errors: parsedResult.errors,
+            })
+            continue
+          }
+          const parsed = parsedResult.event
 
-            logger.debug('SSE event received', parsed)
-            switch (parsed.type) {
-              case 'chat_id': {
-                if (parsed.chatId) {
-                  const isNewChat = !chatIdRef.current
-                  chatIdRef.current = parsed.chatId
-                  const selected = selectedChatIdRef.current
-                  if (selected == null) {
-                    if (isNewChat) {
-                      setResolvedChatId(parsed.chatId)
-                    }
-                  } else if (parsed.chatId === selected) {
-                    setResolvedChatId(parsed.chatId)
-                  }
-                  queryClient.invalidateQueries({
-                    queryKey: taskKeys.list(workspaceId),
-                  })
+          if (parsed.trace?.requestId && parsed.trace.requestId !== streamRequestId) {
+            streamRequestId = parsed.trace.requestId
+            flush()
+          }
+          if (parsed.stream?.streamId) {
+            streamIdRef.current = parsed.stream.streamId
+          }
+          if (parsed.stream?.cursor) {
+            lastCursorRef.current = parsed.stream.cursor
+          } else if (typeof parsed.seq === 'number') {
+            lastCursorRef.current = String(parsed.seq)
+          }
+
+          logger.debug('SSE event received', parsed)
+          switch (parsed.type) {
+            case MothershipStreamV1EventType.session: {
+              const payload = parsed.payload
+              const payloadChatId =
+                payload.kind === MothershipStreamV1SessionKind.chat
+                  ? payload.chatId
+                  : typeof parsed.stream?.chatId === 'string'
+                    ? parsed.stream.chatId
+                    : undefined
+              if (payload.kind === MothershipStreamV1SessionKind.chat && payloadChatId) {
+                const isNewChat = !chatIdRef.current
+                chatIdRef.current = payloadChatId
+                const selected = selectedChatIdRef.current
+                if (selected == null) {
                   if (isNewChat) {
-                    const userMsg = pendingUserMsgRef.current
-                    const activeStreamId = streamIdRef.current
-                    if (userMsg && activeStreamId) {
-                      queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(parsed.chatId), {
-                        id: parsed.chatId,
-                        title: null,
-                        messages: [
-                          {
-                            id: userMsg.id,
-                            role: 'user',
-                            content: userMsg.content,
-                          },
-                        ],
-                        activeStreamId,
-                        resources: [],
-                      })
-                    }
-                    if (!workflowIdRef.current) {
-                      window.history.replaceState(
-                        null,
-                        '',
-                        `/workspace/${workspaceId}/task/${parsed.chatId}`
-                      )
-                    }
+                    setResolvedChatId(payloadChatId)
                   }
+                } else if (payloadChatId === selected) {
+                  setResolvedChatId(payloadChatId)
                 }
-                break
-              }
-              case 'request_id': {
-                const rid = typeof parsed.data === 'string' ? parsed.data : undefined
-                if (rid) {
-                  streamRequestId = rid
-                  flush()
+                queryClient.invalidateQueries({
+                  queryKey: taskKeys.list(workspaceId),
+                })
+                if (isNewChat) {
+                  const userMsg = pendingUserMsgRef.current
+                  const activeStreamId = streamIdRef.current
+                  if (userMsg && activeStreamId) {
+                    queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(payloadChatId), {
+                      id: payloadChatId,
+                      title: null,
+                      messages: [userMsg],
+                      activeStreamId,
+                      resources: resourcesRef.current,
+                    })
+                  }
+                  if (!workflowIdRef.current) {
+                    router.replace(`/workspace/${workspaceId}/task/${payloadChatId}`, {
+                      scroll: false,
+                    })
+                  }
                 }
-                break
               }
-              case 'content': {
-                const chunk = typeof parsed.data === 'string' ? parsed.data : (parsed.content ?? '')
-                if (chunk) {
-                  const contentSource: 'main' | 'subagent' = activeSubagent ? 'subagent' : 'main'
-                  const needsBoundaryNewline =
-                    lastContentSource !== null &&
-                    lastContentSource !== contentSource &&
-                    runningText.length > 0 &&
-                    !runningText.endsWith('\n')
-                  const tb = ensureTextBlock()
-                  const normalizedChunk = needsBoundaryNewline ? `\n${chunk}` : chunk
-                  tb.content = (tb.content ?? '') + normalizedChunk
-                  if (activeSubagent) tb.subagent = activeSubagent
-                  runningText += normalizedChunk
-                  lastContentSource = contentSource
-                  streamingContentRef.current = runningText
-                  flush()
-                }
-                break
+              if (payload.kind === MothershipStreamV1SessionKind.title) {
+                queryClient.invalidateQueries({
+                  queryKey: taskKeys.list(workspaceId),
+                })
+                onTitleUpdateRef.current?.()
               }
-              case 'reasoning': {
-                const d = (
-                  parsed.data && typeof parsed.data === 'object' ? parsed.data : {}
-                ) as Record<string, unknown>
-                const phase = d.phase as string | undefined
-                if (phase === 'start') {
-                  const tb = ensureTextBlock()
-                  tb.content = `${tb.content ?? ''}<thinking>`
-                  runningText += '<thinking>'
-                  streamingContentRef.current = runningText
-                  flush()
-                } else if (phase === 'end') {
-                  const tb = ensureTextBlock()
-                  tb.content = `${tb.content ?? ''}</thinking>`
-                  runningText += '</thinking>'
-                  streamingContentRef.current = runningText
-                  flush()
-                } else {
-                  const chunk =
-                    typeof d.data === 'string' ? d.data : (parsed.content as string | undefined)
-                  if (chunk) {
-                    const tb = ensureTextBlock()
-                    tb.content = (tb.content ?? '') + chunk
-                    runningText += chunk
-                    streamingContentRef.current = runningText
-                    flush()
-                  }
-                }
-                break
+              break
+            }
+            case MothershipStreamV1EventType.text: {
+              const chunk = parsed.payload.text
+              if (chunk) {
+                const contentSource: 'main' | 'subagent' = activeSubagent ? 'subagent' : 'main'
+                const needsBoundaryNewline =
+                  lastContentSource !== null &&
+                  lastContentSource !== contentSource &&
+                  runningText.length > 0 &&
+                  !runningText.endsWith('\n')
+                const tb = ensureTextBlock()
+                const normalizedChunk = needsBoundaryNewline ? `\n${chunk}` : chunk
+                tb.content = (tb.content ?? '') + normalizedChunk
+                if (activeSubagent) tb.subagent = activeSubagent
+                runningText += normalizedChunk
+                lastContentSource = contentSource
+                streamingContentRef.current = runningText
+                flushText()
               }
-              case 'tool_generating':
-              case 'tool_call': {
-                const id = parsed.toolCallId
-                const data = getPayloadData(parsed)
-                const name = parsed.toolName || data?.name || 'unknown'
-                const isPartial = data?.partial === true
-                if (!id) break
-
-                if (name === 'tool_search_tool_regex') {
-                  break
+              break
+            }
+            case MothershipStreamV1EventType.tool: {
+              const payload = parsed.payload
+              const id = payload.toolCallId
+
+              if ('previewPhase' in payload) {
+                const prevSession = previewSessionsRef.current[id]
+                const target =
+                  payload.previewPhase === 'file_preview_target' ? payload.target : undefined
+                const targetKind =
+                  'targetKind' in payload &&
+                  (payload.targetKind === 'new_file' || payload.targetKind === 'file_id')
+                    ? payload.targetKind
+                    : target?.kind === 'new_file' || target?.kind === 'file_id'
+                      ? target.kind
+                      : prevSession?.targetKind
+                const fileId =
+                  'fileId' in payload && typeof payload.fileId === 'string'
+                    ? payload.fileId
+                    : typeof target?.fileId === 'string'
+                      ? target.fileId
+                      : prevSession?.fileId
+                const fileName =
+                  'fileName' in payload && typeof payload.fileName === 'string'
+                    ? payload.fileName
+                    : typeof target?.fileName === 'string'
+                      ? target.fileName
+                      : (prevSession?.fileName ?? '')
+                const operation =
+                  'operation' in payload && typeof payload.operation === 'string'
+                    ? payload.operation
+                    : prevSession?.operation
+                const edit =
+                  ('edit' in payload ? asPayloadRecord(payload.edit) : undefined) ??
+                  prevSession?.edit
+                const streamId = parsed.stream?.streamId ?? prevSession?.streamId ?? ''
+                const nextPreviewVersion =
+                  'previewVersion' in payload &&
+                  typeof payload.previewVersion === 'number' &&
+                  Number.isFinite(payload.previewVersion)
+                    ? payload.previewVersion
+                    : (prevSession?.previewVersion ?? 0) + 1
+                const baseSession: FilePreviewSession = {
+                  schemaVersion: 1,
+                  id,
+                  streamId,
+                  toolCallId: id,
+                  status: prevSession?.status ?? 'pending',
+                  fileName,
+                  ...(fileId ? { fileId } : {}),
+                  ...(targetKind ? { targetKind } : {}),
+                  ...(operation ? { operation } : {}),
+                  ...(edit ? { edit } : {}),
+                  previewText: prevSession?.previewText ?? '',
+                  previewVersion: prevSession?.previewVersion ?? 0,
+                  updatedAt: prevSession?.updatedAt ?? new Date().toISOString(),
+                  ...(prevSession?.completedAt ? { completedAt: prevSession.completedAt } : {}),
                 }
-                const ui = parsed.ui || data?.ui
-                if (ui?.hidden) break
-                const displayTitle = ui?.title || ui?.phaseLabel
-                const phaseLabel = ui?.phaseLabel
-                const args = (data?.arguments ?? data?.input) as Record<string, unknown> | undefined
-                if (!toolMap.has(id)) {
-                  toolMap.set(id, blocks.length)
-                  blocks.push({
-                    type: 'tool_call',
-                    toolCall: {
-                      id,
-                      name,
-                      status: 'executing',
-                      displayTitle,
-                      phaseLabel,
-                      params: args,
-                      calledBy: activeSubagent,
-                    },
-                  })
-                  if (name === 'read' || isResourceToolName(name)) {
-                    if (args) toolArgsMap.set(id, args)
+
+                if (payload.previewPhase === 'file_preview_start') {
+                  const nextSession: FilePreviewSession = {
+                    ...baseSession,
+                    status: 'pending',
+                    updatedAt: new Date().toISOString(),
                   }
-                } else {
-                  const idx = toolMap.get(id)!
-                  const tc = blocks[idx].toolCall
-                  if (tc) {
-                    tc.name = name
-                    if (displayTitle) tc.displayTitle = displayTitle
-                    if (phaseLabel) tc.phaseLabel = phaseLabel
-                    if (args) tc.params = args
+                  if (nextSession.fileId) {
+                    setActiveResourceId(nextSession.fileId)
                   }
+                  applyPreviewSessionUpdate(nextSession)
+                  break
                 }
-                flush()
 
-                // TODO: Uncomment when rich UI for Results tab is ready
-                // if (shouldOpenGenericResource(name)) {
-                //   if (!genericEntryMap.has(id)) {
-                //     const entryIdx = appendGenericEntry({
-                //       toolCallId: id,
-                //       toolName: name,
-                //       displayTitle: displayTitle ?? name,
-                //       status: 'executing',
-                //       params: args,
-                //     })
-                //     genericEntryMap.set(id, entryIdx)
-                //     const opened = addResource({ type: 'generic', id: 'results', title: 'Results' })
-                //     if (opened) onResourceEventRef.current?.()
-                //     else setActiveResourceId('results')
-                //   } else {
-                //     const entryIdx = genericEntryMap.get(id)
-                //     if (entryIdx !== undefined) {
-                //       updateGenericEntry(entryIdx, {
-                //         toolName: name,
-                //         ...(displayTitle && { displayTitle }),
-                //         ...(args && { params: args }),
-                //       })
-                //     }
-                //   }
-                // }
-
-                if (
-                  parsed.type === 'tool_call' &&
-                  ui?.clientExecutable &&
-                  isWorkflowToolName(name) &&
-                  !isPartial &&
-                  !clientExecutionStarted.has(id)
-                ) {
-                  clientExecutionStarted.add(id)
-                  const args = data?.arguments ?? data?.input ?? {}
-                  const targetWorkflowId =
-                    typeof (args as Record<string, unknown>).workflowId === 'string'
-                      ? ((args as Record<string, unknown>).workflowId as string)
-                      : useWorkflowRegistry.getState().activeWorkflowId
-                  if (targetWorkflowId) {
-                    const meta = getWorkflowById(workspaceId, targetWorkflowId)
-                    const wasAdded = addResource({
-                      type: 'workflow',
-                      id: targetWorkflowId,
-                      title: meta?.name ?? 'Workflow',
-                    })
-                    if (!wasAdded && activeResourceIdRef.current !== targetWorkflowId) {
-                      setActiveResourceId(targetWorkflowId)
-                    }
-                    onResourceEventRef.current?.()
+                if (payload.previewPhase === 'file_preview_target') {
+                  const nextSession: FilePreviewSession = {
+                    ...baseSession,
+                    updatedAt: new Date().toISOString(),
+                  }
+                  const nextState = applyPreviewSessionUpdate(nextSession)
+                  const activePreview =
+                    nextState.activeSessionId !== null
+                      ? (nextState.sessions[nextState.activeSessionId] ?? null)
+                      : null
+                  if (activePreview?.id === nextSession.id) {
+                    syncPreviewResourceChrome(activePreview)
                   }
-                  executeRunToolOnClient(id, name, args as Record<string, unknown>)
+                  break
                 }
-                break
-              }
-              case 'tool_call_delta': {
-                const id = parsed.toolCallId
-                const delta = typeof parsed.data === 'string' ? parsed.data : ''
-                if (!id || !delta) break
-
-                const toolName = typeof parsed.toolName === 'string' ? parsed.toolName : ''
-                const streamWorkspaceFile =
-                  activeSubagent === 'file_write' || toolName === 'workspace_file'
-
-                if (streamWorkspaceFile) {
-                  let prev = streamingFileRef.current
-                  if (!prev) {
-                    prev = { fileName: '', content: '' }
-                    streamingFileRef.current = prev
-                    setStreamingFile(prev)
+
+                if (payload.previewPhase === 'file_preview_edit_meta') {
+                  const nextSession: FilePreviewSession = {
+                    ...baseSession,
+                    status: prevSession?.status ?? 'pending',
+                    updatedAt: new Date().toISOString(),
                   }
-                  const raw = prev.content + delta
-                  let fileName = prev.fileName
-                  if (!fileName) {
-                    const m = raw.match(/"fileName"\s*:\s*"([^"]+)"/)
-                    if (m) {
-                      fileName = m[1]
-                    }
+                  applyPreviewSessionUpdate(nextSession)
+                  break
+                }
+
+                if (payload.previewPhase === 'file_preview_content') {
+                  const content = payload.content
+                  const contentMode = payload.contentMode
+                  const nextPreviewText =
+                    contentMode === 'delta' ? (prevSession?.previewText ?? '') + content : content
+                  const nextSession: FilePreviewSession = {
+                    ...baseSession,
+                    status: 'streaming',
+                    previewText: nextPreviewText,
+                    previewVersion: nextPreviewVersion,
+                    updatedAt: new Date().toISOString(),
+                  }
+                  applyPreviewSessionUpdate(nextSession)
+                  const previewToolIdx = toolMap.get(id)
+                  if (previewToolIdx !== undefined && blocks[previewToolIdx].toolCall) {
+                    blocks[previewToolIdx].toolCall!.status = 'executing'
+                  }
+                  break
+                }
+
+                if (payload.previewPhase === 'file_preview_complete') {
+                  const resultData = asPayloadRecord(payload.output)
+                  const completedAt = new Date().toISOString()
+                  const nextSession: FilePreviewSession = {
+                    ...baseSession,
+                    status: 'complete',
+                    previewVersion: payload.previewVersion ?? prevSession?.previewVersion ?? 0,
+                    updatedAt: completedAt,
+                    completedAt,
                   }
-                  const fileIdMatch = raw.match(/"fileId"\s*:\s*"([^"]+)"/)
-                  const matchedResourceId = fileIdMatch?.[1]
-                  if (
-                    matchedResourceId &&
-                    resourcesRef.current.some(
-                      (resource) => resource.type === 'file' && resource.id === matchedResourceId
-                    )
-                  ) {
-                    setActiveResourceId(matchedResourceId)
-                    setResources((rs) => rs.filter((resource) => resource.id !== 'streaming-file'))
-                  } else if (fileName || fileIdMatch) {
-                    const hasStreamingResource = resourcesRef.current.some(
-                      (resource) => resource.id === 'streaming-file'
-                    )
-                    if (!hasStreamingResource) {
-                      addResource({
-                        type: 'file',
-                        id: 'streaming-file',
-                        title: fileName || 'Writing file...',
-                      })
-                    } else if (fileName) {
-                      setResources((rs) =>
-                        rs.map((resource) =>
-                          resource.id === 'streaming-file'
-                            ? { ...resource, title: fileName }
-                            : resource
-                        )
+                  const nextState = applyCompletedPreviewSession(nextSession)
+
+                  if (fileId && resultData?.id) {
+                    const fileName = (resultData.name as string) ?? nextSession.fileName ?? 'File'
+                    const fileResource = { type: 'file' as const, id: fileId, title: fileName }
+                    setResources((rs) => {
+                      const without = rs.filter((r) => r.id !== 'streaming-file')
+                      if (without.some((r) => r.type === 'file' && r.id === fileResource.id)) {
+                        return without
+                      }
+                      return [...without, fileResource]
+                    })
+                    setActiveResourceId(fileId)
+                    if (nextSession.previewText) {
+                      queryClient.setQueryData(
+                        workspaceFilesKeys.content(workspaceId, fileId, 'text'),
+                        nextSession.previewText
                       )
                     }
+                    invalidateResourceQueries(queryClient, workspaceId, 'file', fileId)
+                  } else {
+                    const activePreview =
+                      nextState.activeSessionId !== null
+                        ? (nextState.sessions[nextState.activeSessionId] ?? null)
+                        : null
+                    if (activePreview) {
+                      syncPreviewResourceChrome(activePreview)
+                    }
                   }
-                  const next = { fileName, content: raw }
-                  streamingFileRef.current = next
-                  setStreamingFile(next)
+                  break
                 }
+              }
+
+              if (payload.phase === MothershipStreamV1ToolPhase.args_delta) {
+                const delta = payload.argumentsDelta
+                if (!delta) break
 
                 const idx = toolMap.get(id)
                 if (idx !== undefined && blocks[idx].toolCall) {
                   const tc = blocks[idx].toolCall!
                   tc.streamingArgs = (tc.streamingArgs ?? '') + delta
+                  const displayTitle = resolveStreamingToolDisplayTitle(tc.name, tc.streamingArgs)
+                  if (displayTitle) tc.displayTitle = displayTitle
+
                   flush()
                 }
-
-                // TODO: Uncomment when rich UI for Results tab is ready
-                // if (toolName && shouldOpenGenericResource(toolName)) {
-                //   const entryIdx = genericEntryMap.get(id)
-                //   if (entryIdx !== undefined) {
-                //     const entry = genericResourceDataRef.current.entries[entryIdx]
-                //     if (entry) {
-                //       updateGenericEntry(entryIdx, {
-                //         streamingArgs: (entry.streamingArgs ?? '') + delta,
-                //       })
-                //     }
-                //   }
-                // }
-
                 break
               }
-              case 'tool_result': {
-                const id = parsed.toolCallId || getPayloadData(parsed)?.id
-                if (!id) break
-                const idx = toolMap.get(id)
-                if (idx !== undefined && blocks[idx].toolCall) {
-                  const tc = blocks[idx].toolCall!
 
-                  const payloadData = getPayloadData(parsed)
-                  const resultObj =
-                    parsed.result && typeof parsed.result === 'object'
-                      ? (parsed.result as Record<string, unknown>)
-                      : undefined
-                  const isCancelled =
-                    resultObj?.reason === 'user_cancelled' ||
-                    resultObj?.cancelledByUser === true ||
-                    (payloadData as Record<string, unknown> | undefined)?.reason ===
-                      'user_cancelled' ||
-                    (payloadData as Record<string, unknown> | undefined)?.cancelledByUser === true
-
-                  if (isCancelled) {
-                    tc.status = 'cancelled'
-                    tc.displayTitle = 'Stopped by user'
-                  } else {
-                    tc.status = parsed.success ? 'success' : 'error'
-                  }
-                  tc.streamingArgs = undefined
-                  tc.result = {
-                    success: !!parsed.success,
-                    output: parsed.result ?? getPayloadData(parsed)?.result,
-                    error: (parsed.error ?? getPayloadData(parsed)?.error) as string | undefined,
-                  }
-                  flush()
+              if (payload.phase === MothershipStreamV1ToolPhase.result) {
+                const idx = toolMap.get(id)
+                if (idx === undefined || !blocks[idx].toolCall) {
+                  break
+                }
+                const tc = blocks[idx].toolCall!
+                const outputObj = asPayloadRecord(payload.output)
+                const success =
+                  payload.success ?? payload.status === MothershipStreamV1ToolOutcome.success
+                const isCancelled =
+                  outputObj?.reason === 'user_cancelled' ||
+                  outputObj?.cancelledByUser === true ||
+                  payload.status === MothershipStreamV1ToolOutcome.cancelled
+
+                if (isCancelled) {
+                  tc.status = 'cancelled'
+                  tc.displayTitle = 'Stopped by user'
+                } else {
+                  tc.status = success ? 'success' : 'error'
+                }
+                tc.streamingArgs = undefined
+                tc.result = {
+                  success: !!success,
+                  output: payload.output,
+                  error: typeof payload.error === 'string' ? payload.error : undefined,
+                }
+                flush()
 
-                  if (tc.name === 'read' && tc.status === 'success') {
-                    const readArgs = toolArgsMap.get(id)
-                    const resource = extractResourceFromReadResult(
-                      readArgs?.path as string | undefined,
-                      tc.result.output
-                    )
-                    if (resource && addResource(resource)) {
-                      onResourceEventRef.current?.()
-                    }
+                if (tc.name === ReadTool.id && tc.status === 'success') {
+                  const readArgs = toolArgsMap.get(id)
+                  const resource = extractResourceFromReadResult(
+                    typeof readArgs?.path === 'string' ? readArgs.path : undefined,
+                    tc.result.output
+                  )
+                  if (resource && addResource(resource)) {
+                    onResourceEventRef.current?.()
                   }
+                }
 
-                  if (DEPLOY_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
-                    const output = tc.result?.output as Record<string, unknown> | undefined
-                    const deployedWorkflowId = (output?.workflowId as string) ?? undefined
-                    if (deployedWorkflowId && typeof output?.isDeployed === 'boolean') {
-                      queryClient.invalidateQueries({
-                        queryKey: deploymentKeys.info(deployedWorkflowId),
-                      })
-                      queryClient.invalidateQueries({
-                        queryKey: deploymentKeys.versions(deployedWorkflowId),
-                      })
-                      queryClient.invalidateQueries({
-                        queryKey: workflowKeys.list(workspaceId),
-                      })
-                    }
+                if (DEPLOY_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
+                  const output = tc.result?.output as Record<string, unknown> | undefined
+                  const deployedWorkflowId = (output?.workflowId as string) ?? undefined
+                  if (deployedWorkflowId && typeof output?.isDeployed === 'boolean') {
+                    queryClient.invalidateQueries({
+                      queryKey: deploymentKeys.info(deployedWorkflowId),
+                    })
+                    queryClient.invalidateQueries({
+                      queryKey: deploymentKeys.versions(deployedWorkflowId),
+                    })
+                    queryClient.invalidateQueries({
+                      queryKey: workflowKeys.list(workspaceId),
+                    })
                   }
+                }
 
-                  const extractedResources =
-                    tc.status === 'success' && isResourceToolName(tc.name)
-                      ? extractResourcesFromToolResult(
-                          tc.name,
-                          toolArgsMap.get(id) as Record<string, unknown> | undefined,
-                          tc.result?.output
-                        )
-                      : []
-
-                  for (const resource of extractedResources) {
-                    invalidateResourceQueries(queryClient, workspaceId, resource.type, resource.id)
-                  }
+                if (FOLDER_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
+                  queryClient.invalidateQueries({
+                    queryKey: folderKeys.list(workspaceId),
+                  })
+                }
+                if (WORKFLOW_MUTATION_TOOL_NAMES.has(tc.name) && tc.status === 'success') {
+                  queryClient.invalidateQueries({
+                    queryKey: workflowKeys.list(workspaceId),
+                  })
+                }
 
-                  onToolResultRef.current?.(tc.name, tc.status === 'success', tc.result?.output)
-
-                  if (tc.name === 'workspace_file') {
-                    setStreamingFile(null)
-                    streamingFileRef.current = null
-
-                    const fileResource = extractedResources.find((r) => r.type === 'file')
-                    if (fileResource) {
-                      setResources((rs) => {
-                        const without = rs.filter((r) => r.id !== 'streaming-file')
-                        if (without.some((r) => r.type === 'file' && r.id === fileResource.id)) {
-                          return without
-                        }
-                        return [...without, fileResource]
-                      })
-                      setActiveResourceId(fileResource.id)
-                    } else {
-                      setResources((rs) => rs.filter((r) => r.id !== 'streaming-file'))
-                    }
-                  }
+                const extractedResources =
+                  tc.status === 'success' && isResourceToolName(tc.name)
+                    ? extractResourcesFromToolResult(
+                        tc.name,
+                        toolArgsMap.get(id) as Record<string, unknown> | undefined,
+                        tc.result?.output
+                      )
+                    : []
 
-                  // TODO: Uncomment when rich UI for Results tab is ready
-                  // if (
-                  //   shouldOpenGenericResource(tc.name) ||
-                  //   (isDeferredResourceTool(tc.name) && extractedResources.length === 0)
-                  // ) {
-                  //   const entryIdx = genericEntryMap.get(id)
-                  //   if (entryIdx !== undefined) {
-                  //     updateGenericEntry(entryIdx, {
-                  //       status: tc.status,
-                  //       result: tc.result ?? undefined,
-                  //       streamingArgs: undefined,
-                  //     })
-                  //   } else {
-                  //     const newIdx = appendGenericEntry({
-                  //       toolCallId: id,
-                  //       toolName: tc.name,
-                  //       displayTitle: tc.displayTitle ?? tc.name,
-                  //       status: tc.status,
-                  //       params: toolArgsMap.get(id) as Record<string, unknown> | undefined,
-                  //       result: tc.result ?? undefined,
-                  //     })
-                  //     genericEntryMap.set(id, newIdx)
-                  //     if (addResource({ type: 'generic', id: 'results', title: 'Results' })) {
-                  //       onResourceEventRef.current?.()
-                  //     }
-                  //   }
-                  // }
+                for (const resource of extractedResources) {
+                  invalidateResourceQueries(queryClient, workspaceId, resource.type, resource.id)
                 }
 
-                break
-              }
-              case 'resource_added': {
-                const resource = parsed.resource
-                if (resource?.type && resource?.id) {
-                  const wasAdded = addResource(resource)
-                  invalidateResourceQueries(queryClient, workspaceId, resource.type, resource.id)
+                onToolResultRef.current?.(tc.name, tc.status === 'success', tc.result?.output)
+
+                const workspaceFileOperation =
+                  tc.name === WorkspaceFile.id && typeof tc.params?.operation === 'string'
+                    ? tc.params.operation
+                    : undefined
+                const shouldKeepWorkspacePreviewOpen =
+                  tc.name === WorkspaceFile.id &&
+                  (workspaceFileOperation === 'append' ||
+                    workspaceFileOperation === 'update' ||
+                    workspaceFileOperation === 'patch')
 
-                  if (!wasAdded && activeResourceIdRef.current !== resource.id) {
-                    setActiveResourceId(resource.id)
+                if (
+                  (tc.name === WorkspaceFile.id || tc.name === 'edit_content') &&
+                  !shouldKeepWorkspacePreviewOpen
+                ) {
+                  if (tc.name === WorkspaceFile.id) {
+                    removePreviewSessionImmediate(id)
                   }
-                  onResourceEventRef.current?.()
-
-                  if (resource.type === 'workflow') {
-                    const wasRegistered = ensureWorkflowInRegistry(
-                      resource.id,
-                      resource.title,
-                      workspaceId
-                    )
-                    if (wasAdded && wasRegistered) {
-                      useWorkflowRegistry.getState().setActiveWorkflow(resource.id)
-                    } else {
-                      useWorkflowRegistry.getState().loadWorkflowState(resource.id)
-                    }
+                  const fileResource = extractedResources.find((r) => r.type === 'file')
+                  if (fileResource) {
+                    setResources((rs) => {
+                      const without = rs.filter((r) => r.id !== 'streaming-file')
+                      if (without.some((r) => r.type === 'file' && r.id === fileResource.id)) {
+                        return without
+                      }
+                      return [...without, fileResource]
+                    })
+                    setActiveResourceId(fileResource.id)
+                    invalidateResourceQueries(queryClient, workspaceId, 'file', fileResource.id)
+                  } else if (!activeSubagent || activeSubagent !== FILE_SUBAGENT_ID) {
+                    setResources((rs) => rs.filter((r) => r.id !== 'streaming-file'))
                   }
                 }
                 break
               }
-              case 'resource_deleted': {
-                const resource = parsed.resource
-                if (resource?.type && resource?.id) {
-                  removeResource(resource.type as MothershipResourceType, resource.id)
-                  invalidateResourceQueries(
-                    queryClient,
-                    workspaceId,
-                    resource.type as MothershipResourceType,
-                    resource.id
-                  )
-                  onResourceEventRef.current?.()
+
+              const name = payload.toolName
+              const isPartial = payload.partial === true
+              if (name === ToolSearchToolRegex.id || isToolHiddenInUi(name)) {
+                break
+              }
+              const ui = getToolUI(payload.ui)
+              if (ui?.hidden) break
+              let displayTitle = ui?.title || ui?.phaseLabel
+              const phaseLabel = ui?.phaseLabel
+              const args = payload.arguments as Record<string, unknown> | undefined
+
+              displayTitle = resolveToolDisplayTitle(name, args) ?? displayTitle
+
+              if (name === 'edit_content') {
+                const parentToolCallId =
+                  activePreviewSessionIdRef.current ?? previewSessionRef.current?.toolCallId
+                const parentIdx =
+                  parentToolCallId !== null && parentToolCallId !== undefined
+                    ? toolMap.get(parentToolCallId)
+                    : undefined
+                if (parentIdx !== undefined && blocks[parentIdx].toolCall) {
+                  toolMap.set(id, parentIdx)
+                  const tc = blocks[parentIdx].toolCall!
+                  tc.status = 'executing'
+                  tc.result = undefined
+                  flush()
+                  break
+                }
+              }
+
+              if (!toolMap.has(id)) {
+                toolMap.set(id, blocks.length)
+                blocks.push({
+                  type: 'tool_call',
+                  toolCall: {
+                    id,
+                    name,
+                    status: 'executing',
+                    displayTitle,
+                    phaseLabel,
+                    params: args,
+                    calledBy: activeSubagent,
+                  },
+                })
+                if (name === ReadTool.id || isResourceToolName(name)) {
+                  if (args) toolArgsMap.set(id, args)
                 }
+              } else {
+                const idx = toolMap.get(id)!
+                const tc = blocks[idx].toolCall
+                if (tc) {
+                  tc.name = name
+                  if (displayTitle) tc.displayTitle = displayTitle
+                  if (phaseLabel) tc.phaseLabel = phaseLabel
+                  if (args) tc.params = args
+                }
+              }
+              flush()
+
+              if (isWorkflowToolName(name) && !isPartial) {
+                startClientWorkflowTool(id, name, args ?? {})
+              }
+              break
+            }
+            case MothershipStreamV1EventType.resource: {
+              const payload = parsed.payload
+              const resource = payload.resource
+
+              if (payload.op === MothershipStreamV1ResourceOp.remove) {
+                removeResource(resource.type as MothershipResourceType, resource.id)
+                invalidateResourceQueries(
+                  queryClient,
+                  workspaceId,
+                  resource.type as MothershipResourceType,
+                  resource.id
+                )
+                onResourceEventRef.current?.()
                 break
               }
-              case 'context_compaction_start': {
+
+              const nextResource = {
+                type: resource.type as MothershipResourceType,
+                id: resource.id,
+                title: typeof resource.title === 'string' ? resource.title : resource.id,
+              }
+              const wasAdded = addResource(nextResource)
+              invalidateResourceQueries(
+                queryClient,
+                workspaceId,
+                nextResource.type,
+                nextResource.id
+              )
+
+              if (!wasAdded && activeResourceIdRef.current !== nextResource.id) {
+                setActiveResourceId(nextResource.id)
+              }
+              onResourceEventRef.current?.()
+
+              if (nextResource.type === 'workflow') {
+                const wasRegistered = ensureWorkflowInRegistry(
+                  nextResource.id,
+                  nextResource.title,
+                  workspaceId
+                )
+                if (wasAdded && wasRegistered) {
+                  useWorkflowRegistry.getState().setActiveWorkflow(nextResource.id)
+                } else {
+                  useWorkflowRegistry.getState().loadWorkflowState(nextResource.id)
+                }
+              }
+              break
+            }
+            case MothershipStreamV1EventType.run: {
+              const payload = parsed.payload
+              if (payload.kind === MothershipStreamV1RunKind.compaction_start) {
                 const compactionId = `compaction_${Date.now()}`
                 activeCompactionId = compactionId
                 toolMap.set(compactionId, blocks.length)
@@ -1547,9 +2055,7 @@ export function useChat(
                   },
                 })
                 flush()
-                break
-              }
-              case 'context_compaction': {
+              } else if (payload.kind === MothershipStreamV1RunKind.compaction_done) {
                 const compactionId = activeCompactionId || `compaction_${Date.now()}`
                 activeCompactionId = undefined
                 const idx = toolMap.get(compactionId)
@@ -1569,240 +2075,312 @@ export function useChat(
                   })
                 }
                 flush()
-                break
               }
-              case 'tool_error': {
-                const id = parsed.toolCallId || getPayloadData(parsed)?.id
-                if (!id) break
-                const idx = toolMap.get(id)
-                if (idx !== undefined && blocks[idx].toolCall) {
-                  const toolCallName = blocks[idx].toolCall!.name
-                  blocks[idx].toolCall!.status = 'error'
-                  if (toolCallName === 'workspace_file') {
-                    setStreamingFile(null)
-                    streamingFileRef.current = null
-                    setResources((rs) => rs.filter((resource) => resource.id !== 'streaming-file'))
-                  }
-                  flush()
-
-                  // TODO: Uncomment when rich UI for Results tab is ready
-                  // if (toolCallName && shouldOpenGenericResource(toolCallName)) {
-                  //   const entryIdx = genericEntryMap.get(id)
-                  //   if (entryIdx !== undefined) {
-                  //     updateGenericEntry(entryIdx, { status: 'error', streamingArgs: undefined })
-                  //   }
-                  // }
-                }
+              break
+            }
+            case MothershipStreamV1EventType.span: {
+              const payload = parsed.payload
+              if (payload.kind !== MothershipStreamV1SpanPayloadKind.subagent) {
                 break
               }
-              case 'subagent_start': {
-                const name = parsed.subagent || getPayloadData(parsed)?.agent
-                if (name) {
-                  activeSubagent = name
+              const spanData = asPayloadRecord(payload.data)
+              const parentToolCallId =
+                typeof parsed.scope?.parentToolCallId === 'string'
+                  ? parsed.scope.parentToolCallId
+                  : typeof spanData?.tool_call_id === 'string'
+                    ? spanData.tool_call_id
+                    : undefined
+              const isPendingPause = spanData?.pending === true
+              const name =
+                typeof payload.agent === 'string'
+                  ? payload.agent
+                  : typeof parsed.scope?.agentId === 'string'
+                    ? parsed.scope.agentId
+                    : undefined
+              if (payload.event === MothershipStreamV1SpanLifecycleEvent.start && name) {
+                const isSameActiveSubagent =
+                  activeSubagent === name &&
+                  activeSubagentParentToolCallId &&
+                  parentToolCallId === activeSubagentParentToolCallId
+                activeSubagent = name
+                activeSubagentParentToolCallId = parentToolCallId
+                if (!isSameActiveSubagent) {
                   blocks.push({ type: 'subagent', content: name })
-                  if (name === 'file_write') {
-                    const emptyFile = { fileName: '', content: '' }
-                    // Ref must be updated synchronously: tool_call_delta can arrive before React
-                    // re-renders after setStreamingFile, and the handler only appends when prev exists.
-                    streamingFileRef.current = emptyFile
-                    setStreamingFile(emptyFile)
+                }
+                if (name === FILE_SUBAGENT_ID && !isSameActiveSubagent) {
+                  applyPreviewSessionUpdate({
+                    schemaVersion: 1,
+                    id: parentToolCallId || 'file-preview',
+                    streamId: streamIdRef.current ?? '',
+                    toolCallId: parentToolCallId || 'file-preview',
+                    status: 'pending',
+                    fileName: '',
+                    previewText: '',
+                    previewVersion: 0,
+                    updatedAt: new Date().toISOString(),
+                  })
+                }
+                flush()
+              } else if (payload.event === MothershipStreamV1SpanLifecycleEvent.end) {
+                if (isPendingPause) {
+                  break
+                }
+                if (previewSessionRef.current && !activePreviewSessionIdRef.current) {
+                  const lastFileResource = resourcesRef.current.find(
+                    (r) => r.type === 'file' && r.id !== 'streaming-file'
+                  )
+                  setResources((rs) => rs.filter((r) => r.id !== 'streaming-file'))
+                  if (lastFileResource) {
+                    setActiveResourceId(lastFileResource.id)
                   }
-                  flush()
                 }
-                break
-              }
-              case 'subagent_end': {
                 activeSubagent = undefined
+                activeSubagentParentToolCallId = undefined
                 blocks.push({ type: 'subagent_end' })
                 flush()
-                break
-              }
-              case 'title_updated': {
-                queryClient.invalidateQueries({
-                  queryKey: taskKeys.list(workspaceId),
-                })
-                onTitleUpdateRef.current?.()
-                break
-              }
-              case 'error': {
-                sawStreamError = true
-                setError(parsed.error || 'An error occurred')
-                appendInlineErrorTag(buildInlineErrorTag(parsed))
-                break
-              }
-              case 'done': {
-                sawDoneEvent = true
-                break
               }
+              break
+            }
+            case MothershipStreamV1EventType.error: {
+              sawStreamError = true
+              setError(parsed.payload.message || parsed.payload.error || 'An error occurred')
+              appendInlineErrorTag(buildInlineErrorTag(parsed.payload))
+              break
+            }
+            case MothershipStreamV1EventType.complete: {
+              sawCompleteEvent = true
+              // `complete` is terminal for this stream, even if the transport takes a moment
+              // longer to close.
+              break readLoop
             }
           }
         }
       } finally {
+        if (scheduledTextFlushFrame !== null) {
+          cancelAnimationFrame(scheduledTextFlushFrame)
+          scheduledTextFlushFrame = null
+          flush()
+        }
         if (streamReaderRef.current === reader) {
           streamReaderRef.current = null
         }
       }
-      return {
-        sawStreamError,
-        sawDoneEvent,
-        lastEventId,
-      }
+      return { sawStreamError, sawComplete: sawCompleteEvent }
     },
-    [workspaceId, queryClient, addResource, removeResource]
+    [
+      workspaceId,
+      router,
+      queryClient,
+      addResource,
+      removeResource,
+      applyPreviewSessionUpdate,
+      applyCompletedPreviewSession,
+      removePreviewSessionImmediate,
+      syncPreviewResourceChrome,
+    ]
   )
   processSSEStreamRef.current = processSSEStream
 
-  const persistPartialResponse = useCallback(async () => {
-    const chatId = chatIdRef.current
-    const streamId = streamIdRef.current
-    if (!chatId || !streamId) return
-
-    const content = streamingContentRef.current
-
-    const storedBlocks: TaskStoredContentBlock[] = streamingBlocksRef.current.map((block) => {
-      if (block.type === 'tool_call' && block.toolCall) {
-        const isCancelled =
-          block.toolCall.status === 'executing' || block.toolCall.status === 'cancelled'
-        return {
-          type: block.type,
-          content: block.content,
-          toolCall: {
-            id: block.toolCall.id,
-            name: block.toolCall.name,
-            state: isCancelled ? 'cancelled' : block.toolCall.status,
-            params: block.toolCall.params,
-            result: block.toolCall.result,
-            display: {
-              text: isCancelled ? 'Stopped by user' : block.toolCall.displayTitle,
-            },
-            calledBy: block.toolCall.calledBy,
-          },
-        }
+  const getActiveStreamIdForChat = useCallback(
+    async (chatId: string): Promise<string | null> => {
+      const cached = queryClient.getQueryData<TaskChatHistory>(taskKeys.detail(chatId))
+      if (cached?.activeStreamId) {
+        return cached.activeStreamId
       }
-      return { type: block.type, content: block.content }
-    })
 
-    if (storedBlocks.length > 0) {
-      storedBlocks.push({ type: 'stopped' })
-    }
-
-    try {
-      const res = await fetch(stopPathRef.current, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
+      try {
+        const history = await fetchChatHistory(chatId)
+        queryClient.setQueryData(taskKeys.detail(chatId), history)
+        return history.activeStreamId ?? null
+      } catch (error) {
+        logger.warn('Failed to load chat history while recovering stream', {
           chatId,
-          streamId,
-          content,
-          ...(storedBlocks.length > 0 && { contentBlocks: storedBlocks }),
-        }),
-      })
-      if (res.ok) {
-        streamingContentRef.current = ''
-        streamingBlocksRef.current = []
+          error: error instanceof Error ? error.message : String(error),
+        })
+        return null
       }
-    } catch (err) {
-      logger.warn('Failed to persist partial response', err)
-    }
-  }, [])
-
-  const invalidateChatQueries = useCallback(() => {
-    const activeChatId = chatIdRef.current
-    if (activeChatId) {
-      queryClient.invalidateQueries({
-        queryKey: taskKeys.detail(activeChatId),
-      })
-    }
-    queryClient.invalidateQueries({ queryKey: taskKeys.list(workspaceId) })
-  }, [workspaceId, queryClient])
-
-  const messagesRef = useRef(messages)
-  messagesRef.current = messages
-  const visibleMessageQueue = useMemo(
-    () =>
-      pendingRecoveryMessage
-        ? [
-            pendingRecoveryMessage,
-            ...messageQueue.filter((msg) => msg.id !== pendingRecoveryMessage.id),
-          ]
-        : messageQueue,
-    [messageQueue, pendingRecoveryMessage]
+    },
+    [queryClient]
   )
 
-  const finalize = useCallback(
-    (options?: { error?: boolean }) => {
-      sendingRef.current = false
-      setIsSending(false)
-      setIsReconnecting(false)
-      abortControllerRef.current = null
-      invalidateChatQueries()
-
-      if (!options?.error) {
-        const cid = chatIdRef.current
-        if (cid && onStreamEndRef.current) {
-          onStreamEndRef.current(cid, messagesRef.current)
-        }
+  const fetchStreamBatch = useCallback(
+    async (
+      streamId: string,
+      afterCursor: string,
+      signal?: AbortSignal
+    ): Promise<StreamBatchResponse> => {
+      const response = await fetch(
+        `/api/mothership/chat/stream?streamId=${encodeURIComponent(streamId)}&after=${encodeURIComponent(afterCursor)}&batch=true`,
+        { signal }
+      )
+      if (!response.ok) {
+        throw new Error(`Stream resume batch failed: ${response.status}`)
+      }
+      const batch = parseStreamBatchResponse(await response.json())
+      if (Array.isArray(batch.previewSessions) && batch.previewSessions.length > 0) {
+        seedPreviewSessions(batch.previewSessions)
       }
+      return batch
+    },
+    [seedPreviewSessions]
+  )
 
-      if (options?.error) {
-        pendingRecoveryMessageRef.current = null
-        setPendingRecoveryMessage(null)
-        setMessageQueue([])
-        return
+  const attachToExistingStream = useCallback(
+    async (opts: {
+      streamId: string
+      assistantId: string
+      expectedGen: number
+      initialBatch?: StreamBatchResponse | null
+      afterCursor?: string
+    }): Promise<{ error: boolean; aborted: boolean }> => {
+      const { streamId, assistantId, expectedGen, afterCursor = '0' } = opts
+      let latestCursor = afterCursor
+      let seedEvents = opts.initialBatch?.events ?? []
+      let streamStatus = opts.initialBatch?.status ?? 'unknown'
+
+      const isStaleReconnect = () =>
+        streamGenRef.current !== expectedGen || abortControllerRef.current?.signal.aborted === true
+
+      if (isStaleReconnect()) {
+        return { error: false, aborted: true }
       }
 
-      const recoveryMessage = pendingRecoveryMessageRef.current
-      if (recoveryMessage) {
-        setPendingRecoveryMessage(null)
-        const gen = streamGenRef.current
-        queueMicrotask(() => {
-          if (streamGenRef.current !== gen) return
-          sendMessageRef.current(
-            recoveryMessage.content,
-            recoveryMessage.fileAttachments,
-            recoveryMessage.contexts
+      setTransportReconnecting()
+      setError(null)
+
+      try {
+        while (streamGenRef.current === expectedGen) {
+          if (seedEvents.length > 0) {
+            const replayResult = await processSSEStreamRef.current(
+              buildReplayStream(seedEvents).getReader(),
+              assistantId,
+              expectedGen,
+              { preserveExistingState: true }
+            )
+            latestCursor = String(seedEvents[seedEvents.length - 1]?.eventId ?? latestCursor)
+            lastCursorRef.current = latestCursor
+            seedEvents = []
+
+            if (replayResult.sawStreamError) {
+              return { error: true, aborted: false }
+            }
+          }
+
+          if (isTerminalStreamStatus(streamStatus)) {
+            if (streamStatus === 'error') {
+              setError(RECONNECT_TAIL_ERROR)
+            }
+            return { error: streamStatus === 'error', aborted: false }
+          }
+
+          const activeAbort = abortControllerRef.current
+          if (!activeAbort || activeAbort.signal.aborted) {
+            return { error: false, aborted: true }
+          }
+
+          logger.info('Opening live stream tail', { streamId, afterCursor: latestCursor })
+
+          const sseRes = await fetch(
+            `/api/mothership/chat/stream?streamId=${encodeURIComponent(streamId)}&after=${encodeURIComponent(latestCursor)}`,
+            { signal: activeAbort.signal }
           )
-        })
-        return
-      }
+          if (!sseRes.ok || !sseRes.body) {
+            throw new Error(RECONNECT_TAIL_ERROR)
+          }
 
-      const next = messageQueueRef.current[0]
-      if (next) {
-        setMessageQueue((prev) => prev.filter((m) => m.id !== next.id))
-        const gen = streamGenRef.current
-        queueMicrotask(() => {
-          if (streamGenRef.current !== gen) return
-          sendMessageRef.current(next.content, next.fileAttachments, next.contexts)
-        })
+          if (isStaleReconnect()) {
+            return { error: false, aborted: true }
+          }
+
+          setTransportStreaming()
+
+          const liveResult = await processSSEStreamRef.current(
+            sseRes.body.getReader(),
+            assistantId,
+            expectedGen,
+            { preserveExistingState: true }
+          )
+
+          if (liveResult.sawStreamError) {
+            return { error: true, aborted: false }
+          }
+
+          if (liveResult.sawComplete) {
+            return { error: false, aborted: false }
+          }
+
+          if (isStaleReconnect()) {
+            return { error: false, aborted: true }
+          }
+
+          setTransportReconnecting()
+
+          latestCursor = lastCursorRef.current || latestCursor
+
+          logger.warn('Live stream ended without terminal event, fetching batch', {
+            streamId,
+            latestCursor,
+          })
+
+          const batch = await fetchStreamBatch(streamId, latestCursor, activeAbort.signal)
+          seedEvents = batch.events
+          streamStatus = batch.status
+
+          if (batch.events.length > 0) {
+            latestCursor = String(batch.events[batch.events.length - 1].eventId)
+            lastCursorRef.current = latestCursor
+          }
+
+          if (batch.events.length === 0 && !isTerminalStreamStatus(batch.status)) {
+            if (activeAbort.signal.aborted || streamGenRef.current !== expectedGen) {
+              return { error: false, aborted: true }
+            }
+          }
+        }
+
+        return { error: false, aborted: true }
+      } catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+          return { error: false, aborted: true }
+        }
+        throw err
+      } finally {
+        if (streamGenRef.current === expectedGen) {
+          if (sendingRef.current) {
+            setIsReconnecting(false)
+          } else {
+            setTransportIdle()
+          }
+        }
       }
     },
-    [invalidateChatQueries]
+    [fetchStreamBatch, setTransportIdle, setTransportReconnecting, setTransportStreaming]
   )
-  finalizeRef.current = finalize
+  attachToExistingStreamRef.current = attachToExistingStream
 
   const resumeOrFinalize = useCallback(
     async (opts: {
       streamId: string
       assistantId: string
       gen: number
-      fromEventId: number
-      snapshot?: StreamSnapshot | null
+      afterCursor: string
       signal?: AbortSignal
     }): Promise<void> => {
-      const { streamId, assistantId, gen, fromEventId, snapshot, signal } = opts
+      const { streamId, assistantId, gen, afterCursor, signal } = opts
 
-      const batch =
-        snapshot ??
-        (await (async () => {
-          const b = await fetchStreamBatch(streamId, fromEventId, signal)
-          if (streamGenRef.current !== gen) return null
-          return { events: b.events, status: b.status } as StreamSnapshot
-        })())
-
-      if (!batch || streamGenRef.current !== gen) return
+      const batch = await fetchStreamBatch(streamId, afterCursor, signal)
+      if (streamGenRef.current !== gen) return
 
       if (isTerminalStreamStatus(batch.status)) {
-        finalize(batch.status === 'error' ? { error: true } : undefined)
+        if (batch.events.length > 0) {
+          await processSSEStreamRef.current(
+            buildReplayStream(batch.events).getReader(),
+            assistantId,
+            gen,
+            { preserveExistingState: true }
+          )
+        }
+        finalizeRef.current(batch.status === 'error' ? { error: true } : undefined)
         return
       }
 
@@ -1810,29 +2388,31 @@ export function useChat(
         streamId,
         assistantId,
         expectedGen: gen,
-        snapshot: batch,
-        initialLastEventId: batch.events[batch.events.length - 1]?.eventId ?? fromEventId,
+        initialBatch: batch,
+        afterCursor:
+          batch.events.length > 0
+            ? String(batch.events[batch.events.length - 1].eventId)
+            : afterCursor,
       })
 
       if (streamGenRef.current === gen && !reconnectResult.aborted) {
-        finalize(reconnectResult.error ? { error: true } : undefined)
+        finalizeRef.current(reconnectResult.error ? { error: true } : undefined)
+      } else if (streamGenRef.current === gen && reconnectResult.aborted && !sendingRef.current) {
+        setTransportIdle()
       }
     },
-    [fetchStreamBatch, attachToExistingStream, finalize]
+    [fetchStreamBatch, attachToExistingStream, setTransportIdle]
   )
 
   const retryReconnect = useCallback(
-    async (opts: {
-      streamId: string
-      assistantId: string
-      gen: number
-      initialSnapshot?: StreamSnapshot | null
-    }): Promise<boolean> => {
-      const { streamId, assistantId, gen, initialSnapshot } = opts
+    async (opts: { streamId: string; assistantId: string; gen: number }): Promise<boolean> => {
+      const { streamId, assistantId, gen } = opts
+
+      const isStaleReconnect = () =>
+        streamGenRef.current !== gen || abortControllerRef.current?.signal.aborted === true
 
       for (let attempt = 0; attempt <= MAX_RECONNECT_ATTEMPTS; attempt++) {
-        if (streamGenRef.current !== gen) return true
-        if (abortControllerRef.current?.signal.aborted) return true
+        if (isStaleReconnect()) return true
 
         if (attempt > 0) {
           const delayMs = Math.min(
@@ -1845,10 +2425,27 @@ export function useChat(
             maxAttempts: MAX_RECONNECT_ATTEMPTS,
             delayMs,
           })
-          setIsReconnecting(true)
+
+          if (isStaleReconnect()) return true
+
+          setTransportReconnecting()
           await new Promise((resolve) => setTimeout(resolve, delayMs))
-          if (streamGenRef.current !== gen) return true
-          if (abortControllerRef.current?.signal.aborted) return true
+          if (streamGenRef.current !== gen) {
+            if (!sendingRef.current) {
+              setTransportIdle()
+            } else {
+              setIsReconnecting(false)
+            }
+            return true
+          }
+          if (abortControllerRef.current?.signal.aborted) {
+            if (!sendingRef.current) {
+              setTransportIdle()
+            } else {
+              setIsReconnecting(false)
+            }
+            return true
+          }
         }
 
         try {
@@ -1856,13 +2453,38 @@ export function useChat(
             streamId,
             assistantId,
             gen,
-            fromEventId: lastEventIdRef.current,
-            snapshot: attempt === 0 ? initialSnapshot : undefined,
+            afterCursor: lastCursorRef.current || '0',
             signal: abortControllerRef.current?.signal,
           })
-          return true
+          if (streamGenRef.current !== gen) {
+            if (!sendingRef.current) {
+              setTransportIdle()
+            } else {
+              setIsReconnecting(false)
+            }
+            return true
+          }
+          if (abortControllerRef.current?.signal.aborted) {
+            if (!sendingRef.current) {
+              setTransportIdle()
+            } else {
+              setIsReconnecting(false)
+            }
+            return true
+          }
+          if (!sendingRef.current) {
+            setTransportIdle()
+            return true
+          }
         } catch (err) {
-          if (err instanceof Error && err.name === 'AbortError') return true
+          if (err instanceof Error && err.name === 'AbortError') {
+            if (!sendingRef.current) {
+              setTransportIdle()
+            } else {
+              setIsReconnecting(false)
+            }
+            return true
+          }
           logger.warn('Reconnect attempt failed', {
             streamId,
             attempt: attempt + 1,
@@ -1871,47 +2493,164 @@ export function useChat(
         }
       }
 
-      logger.error('All reconnect attempts exhausted', {
-        streamId,
-        maxAttempts: MAX_RECONNECT_ATTEMPTS,
-      })
-      setIsReconnecting(false)
-      return false
+      logger.error('All reconnect attempts exhausted', {
+        streamId,
+        maxAttempts: MAX_RECONNECT_ATTEMPTS,
+      })
+      if (streamGenRef.current === gen) {
+        setIsReconnecting(false)
+      }
+      return false
+    },
+    [resumeOrFinalize, setTransportIdle, setTransportReconnecting]
+  )
+  retryReconnectRef.current = retryReconnect
+
+  const persistPartialResponse = useCallback(
+    async (overrides?: {
+      chatId?: string
+      streamId?: string
+      content?: string
+      blocks?: ContentBlock[]
+    }) => {
+      const chatId = overrides?.chatId ?? chatIdRef.current
+      const streamId = overrides?.streamId ?? streamIdRef.current
+      if (!chatId || !streamId) return
+
+      const content = overrides?.content ?? streamingContentRef.current
+
+      const sourceBlocks = overrides?.blocks ?? streamingBlocksRef.current
+      const storedBlocks = sourceBlocks.map((block) => {
+        if (block.type === 'tool_call' && block.toolCall) {
+          const isCancelled =
+            block.toolCall.status === 'executing' || block.toolCall.status === 'cancelled'
+          const displayTitle = isCancelled ? 'Stopped by user' : block.toolCall.displayTitle
+          const display =
+            displayTitle || block.toolCall.phaseLabel
+              ? {
+                  ...(displayTitle ? { title: displayTitle } : {}),
+                  ...(block.toolCall.phaseLabel ? { phaseLabel: block.toolCall.phaseLabel } : {}),
+                }
+              : undefined
+          return {
+            type: block.type,
+            content: block.content,
+            toolCall: {
+              id: block.toolCall.id,
+              name: block.toolCall.name,
+              state: isCancelled ? MothershipStreamV1ToolOutcome.cancelled : block.toolCall.status,
+              params: block.toolCall.params,
+              result: block.toolCall.result,
+              ...(display ? { display } : {}),
+              calledBy: block.toolCall.calledBy,
+            },
+          }
+        }
+        return { type: block.type, content: block.content }
+      })
+
+      if (storedBlocks.length > 0) {
+        storedBlocks.push({ type: 'stopped', content: undefined })
+      }
+
+      try {
+        const res = await fetch(stopPathRef.current, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            chatId,
+            streamId,
+            content,
+            ...(storedBlocks.length > 0 && { contentBlocks: storedBlocks }),
+          }),
+        })
+        if (!res.ok) {
+          const payload = await res.json().catch(() => null)
+          throw new Error(
+            typeof payload?.error === 'string'
+              ? payload.error
+              : 'Failed to persist partial response'
+          )
+        }
+        if (!overrides || streamIdRef.current === streamId) {
+          streamingContentRef.current = ''
+          streamingBlocksRef.current = []
+        }
+      } catch (err) {
+        logger.warn('Failed to persist partial response', err)
+        throw err instanceof Error ? err : new Error('Failed to persist partial response')
+      }
+    },
+    []
+  )
+
+  const invalidateChatQueries = useCallback(() => {
+    const activeChatId = chatIdRef.current
+    if (activeChatId) {
+      queryClient.invalidateQueries({
+        queryKey: taskKeys.detail(activeChatId),
+      })
+    }
+    queryClient.invalidateQueries({ queryKey: taskKeys.list(workspaceId) })
+  }, [workspaceId, queryClient])
+
+  const messagesRef = useRef(messages)
+  messagesRef.current = messages
+
+  const finalize = useCallback(
+    (options?: { error?: boolean }) => {
+      reconcileTerminalPreviewSessions()
+      locallyTerminalStreamIdRef.current =
+        streamIdRef.current ?? activeTurnRef.current?.userMessageId ?? undefined
+      clearActiveTurn()
+      setTransportIdle()
+      abortControllerRef.current = null
+      invalidateChatQueries()
+
+      if (!options?.error) {
+        const cid = chatIdRef.current
+        if (cid && onStreamEndRef.current) {
+          onStreamEndRef.current(cid, messagesRef.current)
+        }
+      }
+
+      if (options?.error) {
+        return
+      }
+
+      if (messageQueueRef.current.length > 0) {
+        void enqueueQueueDispatchRef.current({ type: 'send_head' })
+      }
     },
-    [resumeOrFinalize]
+    [clearActiveTurn, invalidateChatQueries, reconcileTerminalPreviewSessions, setTransportIdle]
   )
-  retryReconnectRef.current = retryReconnect
-
-  const sendMessage = useCallback(
-    async (message: string, fileAttachments?: FileAttachmentForApi[], contexts?: ChatContext[]) => {
-      if (!message.trim() || !workspaceId) return
+  finalizeRef.current = finalize
 
-      if (sendingRef.current) {
-        const queued: QueuedMessage = {
-          id: generateId(),
-          content: message,
-          fileAttachments,
-          contexts,
-        }
-        setMessageQueue((prev) => [...prev, queued])
-        return
-      }
+  const startSendMessage = useCallback(
+    async (
+      message: string,
+      fileAttachments?: FileAttachmentForApi[],
+      contexts?: ChatContext[],
+      pendingStopOverride?: Promise<void> | null
+    ) => {
+      if (!message.trim() || !workspaceId) return false
+      const pendingStop = pendingStopOverride ?? pendingStopPromiseRef.current
 
       const gen = ++streamGenRef.current
+      let consumedByTranscript = false
 
       setError(null)
-      setIsSending(true)
-      sendingRef.current = true
+      setTransportStreaming()
+      locallyTerminalStreamIdRef.current = undefined
 
       const userMessageId = generateId()
       const assistantId = generateId()
 
-      pendingUserMsgRef.current = { id: userMessageId, content: message }
       streamIdRef.current = userMessageId
-      lastEventIdRef.current = 0
-      clientExecutionStartedRef.current.clear()
+      lastCursorRef.current = '0'
+      resetStreamingBuffers()
 
-      const storedAttachments: TaskStoredFileAttachment[] | undefined =
+      const storedAttachments: PersistedFileAttachment[] | undefined =
         fileAttachments && fileAttachments.length > 0
           ? fileAttachments.map((f) => ({
               id: f.id,
@@ -1923,30 +2662,6 @@ export function useChat(
           : undefined
 
       const requestChatId = selectedChatIdRef.current ?? chatIdRef.current
-      const previousChatHistory = requestChatId
-        ? queryClient.getQueryData<TaskChatHistory>(taskKeys.detail(requestChatId))
-        : undefined
-      if (requestChatId) {
-        const cachedUserMsg: TaskStoredMessage = {
-          id: userMessageId,
-          role: 'user' as const,
-          content: message,
-          ...(storedAttachments && { fileAttachments: storedAttachments }),
-        }
-        queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(requestChatId), (old) => {
-          return old
-            ? {
-                ...old,
-                messages: [...old.messages, cachedUserMsg],
-                activeStreamId: userMessageId,
-              }
-            : undefined
-        })
-      }
-
-      const userAttachments = storedAttachments?.map(toDisplayAttachment)
-      const previousMessages = messagesRef.current
-
       const messageContexts = contexts?.map((c) => ({
         kind: c.kind,
         label: c.label,
@@ -1956,23 +2671,104 @@ export function useChat(
         ...('fileId' in c && c.fileId ? { fileId: c.fileId } : {}),
         ...('folderId' in c && c.folderId ? { folderId: c.folderId } : {}),
       }))
+      const cachedUserMsg: PersistedMessage = {
+        id: userMessageId,
+        role: 'user' as const,
+        content: message,
+        timestamp: new Date().toISOString(),
+        ...(storedAttachments && { fileAttachments: storedAttachments }),
+        ...(messageContexts && messageContexts.length > 0 ? { contexts: messageContexts } : {}),
+      }
+      pendingUserMsgRef.current = cachedUserMsg
+
+      const userAttachments = storedAttachments?.map((f) => ({
+        id: f.id,
+        filename: f.filename,
+        media_type: f.media_type,
+        size: f.size,
+        previewUrl: f.media_type.startsWith('image/')
+          ? `/api/files/serve/${encodeURIComponent(f.key)}?context=mothership`
+          : undefined,
+      }))
 
-      setMessages((prev) => [
-        ...prev,
-        {
-          id: userMessageId,
-          role: 'user',
-          content: message,
-          attachments: userAttachments,
-          ...(messageContexts && messageContexts.length > 0 ? { contexts: messageContexts } : {}),
-        },
-        { id: assistantId, role: 'assistant', content: '', contentBlocks: [] },
-      ])
+      const optimisticUserMessage: ChatMessage = {
+        id: userMessageId,
+        role: 'user',
+        content: message,
+        attachments: userAttachments,
+        ...(messageContexts && messageContexts.length > 0 ? { contexts: messageContexts } : {}),
+      }
+      const optimisticAssistantMessage: ChatMessage = {
+        id: assistantId,
+        role: 'assistant',
+        content: '',
+        contentBlocks: [],
+      }
+      activeTurnRef.current = {
+        userMessageId,
+        assistantMessageId: assistantId,
+        optimisticUserMessage,
+        optimisticAssistantMessage,
+      }
+
+      const applyOptimisticSend = () => {
+        if (requestChatId) {
+          queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(requestChatId), (old) => {
+            if (!old) return undefined
+            const nextMessages = old.messages.filter((m) => m.id !== userMessageId)
+            return {
+              ...old,
+              resources: old.resources.filter((r) => r.id !== 'streaming-file'),
+              messages: [...nextMessages, cachedUserMsg],
+              activeStreamId: userMessageId,
+            }
+          })
+        }
+
+        setMessages((prev) => {
+          const nextMessages = prev.filter((m) => m.id !== userMessageId && m.id !== assistantId)
+          return [...nextMessages, optimisticUserMessage, optimisticAssistantMessage]
+        })
+      }
+
+      const rollbackOptimisticSend = () => {
+        if (requestChatId) {
+          queryClient.setQueryData<TaskChatHistory>(taskKeys.detail(requestChatId), (old) => {
+            if (!old) return undefined
+            return {
+              ...old,
+              messages: old.messages.filter((m) => m.id !== userMessageId),
+              activeStreamId: old.activeStreamId === userMessageId ? null : old.activeStreamId,
+            }
+          })
+        }
+
+        setMessages((prev) => prev.filter((m) => m.id !== userMessageId && m.id !== assistantId))
+      }
+
+      applyOptimisticSend()
+      consumedByTranscript = true
 
       const abortController = new AbortController()
       abortControllerRef.current = abortController
 
       try {
+        if (pendingStop) {
+          try {
+            await pendingStop
+            // Query invalidation from the stop barrier can briefly stomp the optimistic tail.
+            // Re-apply it before the real POST so the mothership UI stays immediate.
+            applyOptimisticSend()
+          } catch (err) {
+            rollbackOptimisticSend()
+            abortControllerRef.current = null
+            clearActiveTurn()
+            setTransportIdle()
+            setError(err instanceof Error ? err.message : 'Failed to stop the previous response')
+            return false
+          }
+        }
+
         const currentActiveId = activeResourceIdRef.current
         const currentResources = resourcesRef.current
         const resourceAttachments =
@@ -2005,86 +2801,55 @@ export function useChat(
 
         if (!response.ok) {
           const errorData = await response.json().catch(() => ({}))
+          if (response.status === 409) {
+            const conflictStreamId =
+              typeof errorData.activeStreamId === 'string'
+                ? errorData.activeStreamId
+                : userMessageId
+            streamIdRef.current = conflictStreamId
+            const succeeded = await retryReconnect({
+              streamId: conflictStreamId,
+              assistantId,
+              gen,
+            })
+            if (succeeded) return consumedByTranscript
+            if (streamGenRef.current === gen) {
+              finalize({ error: true })
+            }
+            return consumedByTranscript
+          }
           throw new Error(errorData.error || `Request failed: ${response.status}`)
         }
 
         if (!response.body) throw new Error('No response body')
 
-        const termination = await processSSEStream(response.body.getReader(), assistantId, {
-          expectedGen: gen,
-        })
+        const streamResult = await processSSEStream(response.body.getReader(), assistantId, gen)
         if (streamGenRef.current === gen) {
-          if (termination.sawStreamError) {
+          if (streamResult.sawStreamError) {
             finalize({ error: true })
-            return
+            return consumedByTranscript
+          }
+
+          // A live SSE `complete` event is already terminal. Finalize immediately so follow-up
+          // sends do not get spuriously queued behind an already-finished response.
+          if (streamResult.sawComplete) {
+            finalize()
+            return consumedByTranscript
           }
 
           await resumeOrFinalize({
-            streamId: userMessageId,
+            streamId: streamIdRef.current || userMessageId,
             assistantId,
             gen,
-            fromEventId: termination.lastEventId,
+            afterCursor: lastCursorRef.current || '0',
             signal: abortController.signal,
           })
-        }
-      } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') return
-        const errorMessage = err instanceof Error ? err.message : 'Failed to send message'
-        if (requestChatId && isActiveStreamConflictError(errorMessage)) {
-          logger.info('Active stream conflict detected while sending message; reattaching', {
-            chatId: requestChatId,
-            attemptedStreamId: userMessageId,
-          })
-
-          if (previousChatHistory) {
-            queryClient.setQueryData(taskKeys.detail(requestChatId), previousChatHistory)
-          }
-          setMessages(previousMessages)
-          const queuedMessage: QueuedMessage = {
-            id: generateId(),
-            content: message,
-            fileAttachments,
-            contexts,
-          }
-          pendingRecoveryMessageRef.current = queuedMessage
-          setPendingRecoveryMessage(queuedMessage)
-
-          try {
-            const pendingRecovery = await preparePendingStreamRecovery(requestChatId)
-            if (!pendingRecovery) {
-              setError(errorMessage)
-              if (streamGenRef.current === gen) {
-                finalize({ error: true })
-              }
-              return
-            }
-
-            streamIdRef.current = pendingRecovery.streamId
-            lastEventIdRef.current =
-              pendingRecovery.snapshot?.events?.[pendingRecovery.snapshot.events.length - 1]
-                ?.eventId ?? 0
-
-            const rehydratedMessages = messagesRef.current
-            const lastAssistantMsg = [...rehydratedMessages]
-              .reverse()
-              .find((m) => m.role === 'assistant')
-            const recoveryAssistantId = lastAssistantMsg?.id ?? assistantId
-
-            await resumeOrFinalize({
-              streamId: pendingRecovery.streamId,
-              assistantId: recoveryAssistantId,
-              gen,
-              fromEventId: lastEventIdRef.current,
-              snapshot: pendingRecovery.snapshot,
-            })
-            return
-          } catch (recoveryError) {
-            logger.warn('Failed to recover active stream after conflict', {
-              chatId: requestChatId,
-              error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
-            })
+          if (streamGenRef.current === gen && sendingRef.current) {
+            finalize()
           }
         }
+      } catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') return consumedByTranscript
 
         const activeStreamId = streamIdRef.current
         if (activeStreamId && streamGenRef.current === gen) {
@@ -2093,15 +2858,16 @@ export function useChat(
             assistantId,
             gen,
           })
-          if (succeeded) return
+          if (succeeded) return consumedByTranscript
         }
 
-        setError(errorMessage)
+        setError(err instanceof Error ? err.message : 'Failed to send message')
         if (streamGenRef.current === gen) {
           finalize({ error: true })
         }
-        return
+        return consumedByTranscript
       }
+      return consumedByTranscript
     },
     [
       workspaceId,
@@ -2110,75 +2876,35 @@ export function useChat(
       finalize,
       resumeOrFinalize,
       retryReconnect,
-      preparePendingStreamRecovery,
+      clearActiveTurn,
+      resetStreamingBuffers,
+      setTransportIdle,
+      setTransportStreaming,
     ]
   )
-  sendMessageRef.current = sendMessage
-
-  const stopGeneration = useCallback(async () => {
-    const wasSending = sendingRef.current
-    const sid =
-      streamIdRef.current ||
-      queryClient.getQueryData<TaskChatHistory>(taskKeys.detail(chatIdRef.current))
-        ?.activeStreamId ||
-      undefined
-
-    streamGenRef.current++
-    streamReaderRef.current?.cancel().catch(() => {})
-    streamReaderRef.current = null
-    abortControllerRef.current?.abort()
-    abortControllerRef.current = null
-    sendingRef.current = false
-    setIsSending(false)
-    setIsReconnecting(false)
-    lastEventIdRef.current = 0
-    pendingRecoveryMessageRef.current = null
-    setPendingRecoveryMessage(null)
-
-    setMessages((prev) =>
-      prev.map((msg) => {
-        if (!msg.contentBlocks?.some((b) => b.toolCall?.status === 'executing')) return msg
-        const updated = msg.contentBlocks!.map((block) => {
-          if (block.toolCall?.status !== 'executing') return block
-          return {
-            ...block,
-            toolCall: {
-              ...block.toolCall,
-              status: 'cancelled' as const,
-              displayTitle: 'Stopped by user',
-            },
-          }
-        })
-        updated.push({ type: 'stopped' as const })
-        return { ...msg, contentBlocks: updated }
-      })
-    )
-
-    if (sid) {
-      fetch('/api/copilot/chat/abort', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ streamId: sid }),
-      }).catch(() => {})
-    }
+  const sendMessage = useCallback(
+    async (message: string, fileAttachments?: FileAttachmentForApi[], contexts?: ChatContext[]) => {
+      if (!message.trim() || !workspaceId) return
 
-    if (wasSending && !chatIdRef.current) {
-      const start = Date.now()
-      while (!chatIdRef.current && Date.now() - start < 3000) {
-        await new Promise((r) => setTimeout(r, 50))
+      if (sendingRef.current) {
+        const queued: QueuedMessage = {
+          id: generateId(),
+          content: message,
+          fileAttachments,
+          contexts,
+        }
+        setMessageQueue((prev) => [...prev, queued])
+        return
       }
-    }
-
-    if (wasSending && chatIdRef.current) {
-      await persistPartialResponse()
-    }
-    invalidateChatQueries()
-    setStreamingFile(null)
-    streamingFileRef.current = null
-    setResources((rs) => rs.filter((resource) => resource.id !== 'streaming-file'))
 
+      await startSendMessage(message, fileAttachments, contexts)
+    },
+    [workspaceId, startSendMessage]
+  )
+  const cancelActiveWorkflowExecutions = useCallback(() => {
     const execState = useExecutionStore.getState()
     const consoleStore = useTerminalConsoleStore.getState()
+
     for (const [workflowId, wfExec] of execState.workflowExecutions) {
       if (!wfExec.isExecuting) continue
 
@@ -2212,75 +2938,292 @@ export function useChat(
       })
 
       executionStream.cancel(workflowId)
-      consolePersistence.executionEnded()
       execState.setIsExecuting(workflowId, false)
       execState.setIsDebugging(workflowId, false)
       execState.setActiveBlocks(workflowId, new Set())
 
       reportManualRunToolStop(workflowId, toolCallId).catch(() => {})
     }
-  }, [invalidateChatQueries, persistPartialResponse, executionStream])
+  }, [executionStream])
 
-  const removeFromQueue = useCallback((id: string) => {
-    if (pendingRecoveryMessageRef.current?.id === id) {
-      pendingRecoveryMessageRef.current = null
-      setPendingRecoveryMessage(null)
-      return
+  const stopGeneration = useCallback(async () => {
+    if (pendingStopPromiseRef.current) {
+      return pendingStopPromiseRef.current
+    }
+
+    const wasSending = sendingRef.current
+    const sid =
+      streamIdRef.current ||
+      activeTurnRef.current?.userMessageId ||
+      queryClient.getQueryData<TaskChatHistory>(taskKeys.detail(chatIdRef.current))
+        ?.activeStreamId ||
+      undefined
+    const stopContentSnapshot = streamingContentRef.current
+    const stopBlocksSnapshot = streamingBlocksRef.current.map((block) => ({
+      ...block,
+      ...(block.options ? { options: [...block.options] } : {}),
+      ...(block.toolCall ? { toolCall: { ...block.toolCall } } : {}),
+    }))
+
+    locallyTerminalStreamIdRef.current = sid
+    streamGenRef.current++
+    clearActiveTurn()
+    streamReaderRef.current?.cancel().catch(() => {})
+    streamReaderRef.current = null
+    abortControllerRef.current?.abort('user_stop:client_stopGeneration')
+    abortControllerRef.current = null
+    setTransportIdle()
+
+    setMessages((prev) =>
+      prev.map((msg) => {
+        if (!msg.contentBlocks?.some((b) => b.toolCall?.status === 'executing')) return msg
+        const updated = msg.contentBlocks!.map((block) => {
+          if (block.toolCall?.status !== 'executing') return block
+          return {
+            ...block,
+            toolCall: {
+              ...block.toolCall,
+              status: 'cancelled' as const,
+              displayTitle: 'Stopped by user',
+            },
+          }
+        })
+        updated.push({ type: 'stopped' as const })
+        return { ...msg, contentBlocks: updated }
+      })
+    )
+
+    // Cancel active run-tool executions before waiting for the server-side stream
+    // shutdown barrier; otherwise the abort settle can sit behind tool execution teardown.
+    cancelActiveWorkflowExecutions()
+
+    const stopBarrier = (async () => {
+      try {
+        if (wasSending && !chatIdRef.current) {
+          const start = Date.now()
+          while (!chatIdRef.current && Date.now() - start < 3000) {
+            await new Promise((r) => setTimeout(r, 50))
+          }
+        }
+
+        const resolvedChatId = chatIdRef.current
+        const abortPromise = sid
+          ? (async () => {
+              const res = await fetch('/api/mothership/chat/abort', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                  streamId: sid,
+                  ...(resolvedChatId ? { chatId: resolvedChatId } : {}),
+                }),
+              })
+              if (!res.ok) {
+                const payload = await res.json().catch(() => null)
+                throw new Error(
+                  typeof payload?.error === 'string'
+                    ? payload.error
+                    : 'Failed to abort previous response'
+                )
+              }
+            })()
+          : Promise.resolve()
+
+        if (wasSending && resolvedChatId) {
+          await persistPartialResponse({
+            chatId: resolvedChatId,
+            streamId: sid,
+            content: stopContentSnapshot,
+            blocks: stopBlocksSnapshot,
+          })
+        }
+
+        await abortPromise
+      } finally {
+        invalidateChatQueries()
+        resetEphemeralPreviewState({ removeStreamingResource: true })
+      }
+    })()
+
+    pendingStopPromiseRef.current = stopBarrier
+    try {
+      await stopBarrier
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to stop the previous response')
+      throw err
+    } finally {
+      if (pendingStopPromiseRef.current === stopBarrier) {
+        pendingStopPromiseRef.current = null
+      }
+    }
+  }, [
+    cancelActiveWorkflowExecutions,
+    invalidateChatQueries,
+    persistPartialResponse,
+    queryClient,
+    resetEphemeralPreviewState,
+    clearActiveTurn,
+    setTransportIdle,
+  ])
+
+  const runQueueDispatchLoop = useCallback(async () => {
+    if (queueDispatchTaskRef.current) {
+      return queueDispatchTaskRef.current
     }
-    messageQueueRef.current = messageQueueRef.current.filter((m) => m.id !== id)
+
+    const task = (async () => {
+      while (true) {
+        const action = queueDispatchActionsRef.current.shift()
+        if (!action) return
+
+        if (action.epoch !== queueDispatchEpochRef.current) {
+          continue
+        }
+
+        const msg = messageQueueRef.current[0]
+        if (!msg) continue
+
+        let originalIndex = 0
+        let removedFromQueue = false
+
+        try {
+          const currentIndex = messageQueueRef.current.findIndex((queued) => queued.id === msg.id)
+          if (currentIndex !== -1) {
+            originalIndex = currentIndex
+            removedFromQueue = true
+            setMessageQueue((prev) => prev.filter((queued) => queued.id !== msg.id))
+          }
+
+          const consumed = await startSendMessage(msg.content, msg.fileAttachments, msg.contexts)
+          if (!consumed && removedFromQueue && action.epoch === queueDispatchEpochRef.current) {
+            setMessageQueue((prev) => {
+              if (prev.some((queued) => queued.id === msg.id)) return prev
+              const next = [...prev]
+              next.splice(Math.min(originalIndex, next.length), 0, msg)
+              return next
+            })
+          }
+        } catch {
+          if (removedFromQueue && action.epoch === queueDispatchEpochRef.current) {
+            setMessageQueue((prev) => {
+              if (prev.some((queued) => queued.id === msg.id)) return prev
+              const next = [...prev]
+              next.splice(Math.min(originalIndex, next.length), 0, msg)
+              return next
+            })
+          }
+        }
+      }
+    })()
+
+    queueDispatchTaskRef.current = task
+
+    return task.finally(() => {
+      if (queueDispatchTaskRef.current === task) {
+        queueDispatchTaskRef.current = null
+      }
+      if (queueDispatchActionsRef.current.length > 0) {
+        void queueDispatchLoopRef.current()
+      }
+    })
+  }, [startSendMessage])
+  queueDispatchLoopRef.current = runQueueDispatchLoop
+
+  const enqueueQueueDispatch = useCallback((action: QueueDispatchActionInput) => {
+    const epoch = queueDispatchEpochRef.current
+    queueDispatchActionsRef.current.push({ ...action, epoch } as QueueDispatchAction)
+    return queueDispatchLoopRef.current()
+  }, [])
+  enqueueQueueDispatchRef.current = enqueueQueueDispatch
+
+  const removeFromQueue = useCallback((id: string) => {
     setMessageQueue((prev) => prev.filter((m) => m.id !== id))
   }, [])
 
-  const sendNow = useCallback(
+  const sendQueuedMessageImmediately = useCallback(
     async (id: string) => {
-      const recoveryMessage = pendingRecoveryMessageRef.current
-      const msg =
-        recoveryMessage?.id === id
-          ? recoveryMessage
-          : messageQueueRef.current.find((m) => m.id === id)
-      if (!msg) return
-      // Eagerly update ref so a rapid second click finds the message already gone
-      if (recoveryMessage?.id === id) {
-        pendingRecoveryMessageRef.current = null
-        setPendingRecoveryMessage(null)
-      } else {
-        messageQueueRef.current = messageQueueRef.current.filter((m) => m.id !== id)
+      const epoch = queueDispatchEpochRef.current
+      const initialIndex = messageQueueRef.current.findIndex((m) => m.id === id)
+      if (initialIndex === -1) return
+      const msg = messageQueueRef.current[initialIndex]
+
+      if (queuedMessageDispatchIdsRef.current.has(msg.id)) {
+        return
+      }
+      queuedMessageDispatchIdsRef.current.add(msg.id)
+
+      // Explicit queue sends should supersede any older auto-drain work scheduled by finalize().
+      queueDispatchActionsRef.current = queueDispatchActionsRef.current.filter(
+        (queuedAction) => queuedAction.type !== 'send_head'
+      )
+
+      let originalIndex = initialIndex
+      let removedFromQueue = false
+      const restoreQueuedMessage = () => {
+        if (!removedFromQueue || epoch !== queueDispatchEpochRef.current) {
+          return
+        }
+        setMessageQueue((prev) => {
+          if (prev.some((queued) => queued.id === msg.id)) return prev
+          const next = [...prev]
+          next.splice(Math.min(originalIndex, next.length), 0, msg)
+          return next
+        })
       }
-      await stopGeneration()
-      if (recoveryMessage?.id !== id) {
-        setMessageQueue((prev) => prev.filter((m) => m.id !== id))
+
+      try {
+        const currentIndex = messageQueueRef.current.findIndex((queued) => queued.id === msg.id)
+        if (currentIndex === -1) {
+          return
+        }
+
+        originalIndex = currentIndex
+        removedFromQueue = true
+        setMessageQueue((prev) => prev.filter((queued) => queued.id !== msg.id))
+
+        const pendingStop = sendingRef.current ? stopGeneration() : pendingStopPromiseRef.current
+        const consumed = await startSendMessage(
+          msg.content,
+          msg.fileAttachments,
+          msg.contexts,
+          pendingStop
+        )
+
+        if (!consumed) {
+          restoreQueuedMessage()
+        }
+      } catch {
+        restoreQueuedMessage()
+      } finally {
+        queuedMessageDispatchIdsRef.current.delete(msg.id)
       }
-      await sendMessage(msg.content, msg.fileAttachments, msg.contexts)
     },
-    [stopGeneration, sendMessage]
+    [startSendMessage, stopGeneration]
   )
 
-  const editQueuedMessage = useCallback((id: string): QueuedMessage | undefined => {
-    const recoveryMessage = pendingRecoveryMessageRef.current
-    if (recoveryMessage?.id === id) {
-      pendingRecoveryMessageRef.current = null
-      setPendingRecoveryMessage(null)
-      return recoveryMessage
-    }
+  const sendNow = useCallback(
+    async (id: string) => {
+      await sendQueuedMessageImmediately(id)
+    },
+    [sendQueuedMessageImmediately]
+  )
 
+  const editQueuedMessage = useCallback((id: string): QueuedMessage | undefined => {
     const msg = messageQueueRef.current.find((m) => m.id === id)
     if (!msg) return undefined
-    messageQueueRef.current = messageQueueRef.current.filter((m) => m.id !== id)
     setMessageQueue((prev) => prev.filter((m) => m.id !== id))
     return msg
   }, [])
 
   useEffect(() => {
     return () => {
+      clearQueueDispatchState()
       streamReaderRef.current = null
       abortControllerRef.current = null
       streamGenRef.current++
+      clearActiveTurn()
       sendingRef.current = false
-      lastEventIdRef.current = 0
-      clientExecutionStartedRef.current.clear()
-      pendingRecoveryMessageRef.current = null
     }
-  }, [])
+  }, [clearQueueDispatchState, clearActiveTurn])
 
   return {
     messages,
@@ -2296,11 +3239,11 @@ export function useChat(
     addResource,
     removeResource,
     reorderResources,
-    messageQueue: visibleMessageQueue,
+    messageQueue,
     removeFromQueue,
     sendNow,
     editQueuedMessage,
-    streamingFile,
+    previewSession,
     genericResourceData,
   }
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions.test.tsx b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions.test.tsx
new file mode 100644
index 00000000000..863df51596d
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions.test.tsx
@@ -0,0 +1,182 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import type { FilePreviewSession } from '@/lib/copilot/request/session'
+import {
+  buildCompletedPreviewSessions,
+  INITIAL_FILE_PREVIEW_SESSIONS_STATE,
+  reduceFilePreviewSessions,
+} from '@/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions'
+
+function createSession(
+  overrides: Partial<FilePreviewSession> & Pick<FilePreviewSession, 'id' | 'toolCallId'>
+): FilePreviewSession {
+  return {
+    schemaVersion: 1,
+    id: overrides.id,
+    streamId: overrides.streamId ?? 'stream-1',
+    toolCallId: overrides.toolCallId,
+    status: overrides.status ?? 'streaming',
+    fileName: overrides.fileName ?? `${overrides.id}.md`,
+    previewText: overrides.previewText ?? '',
+    previewVersion: overrides.previewVersion ?? 1,
+    updatedAt: overrides.updatedAt ?? '2026-04-10T00:00:00.000Z',
+    ...(overrides.fileId ? { fileId: overrides.fileId } : {}),
+    ...(overrides.targetKind ? { targetKind: overrides.targetKind } : {}),
+    ...(overrides.operation ? { operation: overrides.operation } : {}),
+    ...(overrides.edit ? { edit: overrides.edit } : {}),
+    ...(overrides.completedAt ? { completedAt: overrides.completedAt } : {}),
+  }
+}
+
+describe('reduceFilePreviewSessions', () => {
+  it('builds complete sessions for terminal stream reconciliation', () => {
+    const completedAt = '2026-04-10T00:00:10.000Z'
+    const nextSessions = buildCompletedPreviewSessions(
+      {
+        'preview-1': createSession({
+          id: 'preview-1',
+          toolCallId: 'preview-1',
+          status: 'pending',
+          previewText: 'draft',
+        }),
+        'preview-2': createSession({
+          id: 'preview-2',
+          toolCallId: 'preview-2',
+          status: 'streaming',
+          previewText: 'partial',
+        }),
+        'preview-3': createSession({
+          id: 'preview-3',
+          toolCallId: 'preview-3',
+          status: 'complete',
+          previewText: 'done',
+          completedAt: '2026-04-10T00:00:03.000Z',
+        }),
+      },
+      completedAt
+    )
+
+    expect(nextSessions).toHaveLength(2)
+    expect(nextSessions.map((session) => session.id)).toEqual(['preview-1', 'preview-2'])
+    expect(nextSessions.every((session) => session.status === 'complete')).toBe(true)
+    expect(nextSessions.every((session) => session.updatedAt === completedAt)).toBe(true)
+    expect(nextSessions.every((session) => session.completedAt === completedAt)).toBe(true)
+  })
+
+  it('hydrates the latest active preview session', () => {
+    const state = reduceFilePreviewSessions(INITIAL_FILE_PREVIEW_SESSIONS_STATE, {
+      type: 'hydrate',
+      sessions: [
+        createSession({
+          id: 'preview-1',
+          toolCallId: 'preview-1',
+          previewVersion: 1,
+          updatedAt: '2026-04-10T00:00:00.000Z',
+        }),
+        createSession({
+          id: 'preview-2',
+          toolCallId: 'preview-2',
+          previewVersion: 2,
+          updatedAt: '2026-04-10T00:00:01.000Z',
+          previewText: 'latest',
+        }),
+      ],
+    })
+
+    expect(state.activeSessionId).toBe('preview-2')
+    expect(state.sessions['preview-2']?.previewText).toBe('latest')
+  })
+
+  it('drops the active session when it completes and promotes the next active session', () => {
+    const hydratedState = reduceFilePreviewSessions(INITIAL_FILE_PREVIEW_SESSIONS_STATE, {
+      type: 'hydrate',
+      sessions: [
+        createSession({
+          id: 'preview-1',
+          toolCallId: 'preview-1',
+          previewVersion: 1,
+          updatedAt: '2026-04-10T00:00:00.000Z',
+        }),
+        createSession({
+          id: 'preview-2',
+          toolCallId: 'preview-2',
+          previewVersion: 2,
+          updatedAt: '2026-04-10T00:00:01.000Z',
+        }),
+      ],
+    })
+    const completedState = reduceFilePreviewSessions(hydratedState, {
+      type: 'complete',
+      session: createSession({
+        id: 'preview-2',
+        toolCallId: 'preview-2',
+        status: 'complete',
+        previewVersion: 3,
+        updatedAt: '2026-04-10T00:00:02.000Z',
+        completedAt: '2026-04-10T00:00:02.000Z',
+      }),
+    })
+
+    expect(completedState.activeSessionId).toBe('preview-1')
+    expect(completedState.sessions['preview-1']?.id).toBe('preview-1')
+  })
+
+  it('clears active session when the only session completes', () => {
+    const onlyStreaming = reduceFilePreviewSessions(INITIAL_FILE_PREVIEW_SESSIONS_STATE, {
+      type: 'upsert',
+      session: createSession({
+        id: 'preview-1',
+        toolCallId: 'preview-1',
+        previewVersion: 2,
+        updatedAt: '2026-04-10T00:00:01.000Z',
+        previewText: 'final',
+      }),
+    })
+
+    const completed = reduceFilePreviewSessions(onlyStreaming, {
+      type: 'complete',
+      session: createSession({
+        id: 'preview-1',
+        toolCallId: 'preview-1',
+        status: 'complete',
+        previewVersion: 3,
+        updatedAt: '2026-04-10T00:00:02.000Z',
+        completedAt: '2026-04-10T00:00:02.000Z',
+        previewText: 'final',
+      }),
+    })
+
+    expect(completed.activeSessionId).toBeNull()
+    expect(completed.sessions['preview-1']?.status).toBe('complete')
+  })
+
+  it('ignores stale complete events for a newer active session', () => {
+    const activeState = reduceFilePreviewSessions(INITIAL_FILE_PREVIEW_SESSIONS_STATE, {
+      type: 'upsert',
+      session: createSession({
+        id: 'preview-1',
+        toolCallId: 'preview-1',
+        previewVersion: 3,
+        updatedAt: '2026-04-10T00:00:03.000Z',
+      }),
+    })
+
+    const staleCompleteState = reduceFilePreviewSessions(activeState, {
+      type: 'complete',
+      session: createSession({
+        id: 'preview-1',
+        toolCallId: 'preview-1',
+        status: 'complete',
+        previewVersion: 2,
+        updatedAt: '2026-04-10T00:00:02.000Z',
+        completedAt: '2026-04-10T00:00:02.000Z',
+      }),
+    })
+
+    expect(staleCompleteState.activeSessionId).toBe('preview-1')
+    expect(staleCompleteState.sessions['preview-1']?.status).toBe('streaming')
+    expect(staleCompleteState.sessions['preview-1']?.previewVersion).toBe(3)
+  })
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions.ts
new file mode 100644
index 00000000000..6782585bbbb
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-file-preview-sessions.ts
@@ -0,0 +1,201 @@
+import { useCallback, useMemo, useReducer } from 'react'
+import type { FilePreviewSession } from '@/lib/copilot/request/session'
+
+export interface FilePreviewSessionsState {
+  activeSessionId: string | null
+  sessions: Record<string, FilePreviewSession>
+}
+
+export type FilePreviewSessionsAction =
+  | { type: 'hydrate'; sessions: FilePreviewSession[] }
+  | { type: 'upsert'; session: FilePreviewSession; activate?: boolean }
+  | { type: 'complete'; session: FilePreviewSession }
+  | { type: 'remove'; sessionId: string }
+  | { type: 'reset' }
+
+export const INITIAL_FILE_PREVIEW_SESSIONS_STATE: FilePreviewSessionsState = {
+  activeSessionId: null,
+  sessions: {},
+}
+
+export function shouldReplaceSession(
+  current: FilePreviewSession | undefined,
+  next: FilePreviewSession
+): boolean {
+  if (!current) return true
+  if (next.previewVersion !== current.previewVersion) {
+    return next.previewVersion > current.previewVersion
+  }
+  return next.updatedAt >= current.updatedAt
+}
+
+export function pickActiveSessionId(
+  sessions: Record<string, FilePreviewSession>,
+  preferredId?: string | null
+): string | null {
+  if (preferredId && sessions[preferredId]?.status !== 'complete') {
+    return preferredId
+  }
+
+  let latestActive: FilePreviewSession | null = null
+  for (const session of Object.values(sessions)) {
+    if (session.status === 'complete') continue
+    if (!latestActive || shouldReplaceSession(latestActive, session)) {
+      latestActive = session
+    }
+  }
+
+  return latestActive?.id ?? null
+}
+
+export function buildCompletedPreviewSessions(
+  sessions: Record<string, FilePreviewSession>,
+  completedAt: string
+): FilePreviewSession[] {
+  return Object.values(sessions)
+    .filter((session) => session.status !== 'complete')
+    .map((session) => ({
+      ...session,
+      status: 'complete' as const,
+      updatedAt: completedAt,
+      completedAt,
+    }))
+}
+
+export function reduceFilePreviewSessions(
+  state: FilePreviewSessionsState,
+  action: FilePreviewSessionsAction
+): FilePreviewSessionsState {
+  switch (action.type) {
+    case 'hydrate': {
+      if (action.sessions.length === 0) {
+        return state
+      }
+
+      const nextSessions = { ...state.sessions }
+      for (const session of action.sessions) {
+        if (shouldReplaceSession(nextSessions[session.id], session)) {
+          nextSessions[session.id] = session
+        }
+      }
+
+      return {
+        sessions: nextSessions,
+        activeSessionId: pickActiveSessionId(nextSessions, state.activeSessionId),
+      }
+    }
+
+    case 'upsert': {
+      if (!shouldReplaceSession(state.sessions[action.session.id], action.session)) {
+        return state
+      }
+
+      const nextSessions = {
+        ...state.sessions,
+        [action.session.id]: action.session,
+      }
+
+      return {
+        sessions: nextSessions,
+        activeSessionId:
+          action.activate === false
+            ? pickActiveSessionId(nextSessions, state.activeSessionId)
+            : action.session.status === 'complete'
+              ? pickActiveSessionId(nextSessions, state.activeSessionId)
+              : action.session.id,
+      }
+    }
+
+    case 'complete': {
+      if (!shouldReplaceSession(state.sessions[action.session.id], action.session)) {
+        return state
+      }
+
+      const nextSessions = {
+        ...state.sessions,
+        [action.session.id]: action.session,
+      }
+
+      return {
+        sessions: nextSessions,
+        activeSessionId:
+          state.activeSessionId === action.session.id
+            ? pickActiveSessionId(nextSessions, null)
+            : state.activeSessionId,
+      }
+    }
+
+    case 'remove': {
+      if (!state.sessions[action.sessionId]) {
+        return state
+      }
+
+      const nextSessions = { ...state.sessions }
+      delete nextSessions[action.sessionId]
+
+      return {
+        sessions: nextSessions,
+        activeSessionId:
+          state.activeSessionId === action.sessionId
+            ? pickActiveSessionId(nextSessions, null)
+            : state.activeSessionId,
+      }
+    }
+
+    case 'reset':
+      return INITIAL_FILE_PREVIEW_SESSIONS_STATE
+
+    default:
+      return state
+  }
+}
+
+export function useFilePreviewSessions() {
+  const [state, dispatch] = useReducer(
+    reduceFilePreviewSessions,
+    INITIAL_FILE_PREVIEW_SESSIONS_STATE
+  )
+
+  const previewSession = useMemo(
+    () => (state.activeSessionId ? (state.sessions[state.activeSessionId] ?? null) : null),
+    [state.activeSessionId, state.sessions]
+  )
+
+  const hydratePreviewSessions = useCallback((sessions: FilePreviewSession[]) => {
+    dispatch({ type: 'hydrate', sessions })
+  }, [])
+
+  const upsertPreviewSession = useCallback(
+    (session: FilePreviewSession, options?: { activate?: boolean }) => {
+      dispatch({
+        type: 'upsert',
+        session,
+        ...(options?.activate === false ? { activate: false } : {}),
+      })
+    },
+    []
+  )
+
+  const completePreviewSession = useCallback((session: FilePreviewSession) => {
+    dispatch({ type: 'complete', session })
+  }, [])
+
+  const removePreviewSession = useCallback((sessionId: string) => {
+    dispatch({ type: 'remove', sessionId })
+  }, [])
+
+  const resetPreviewSessions = useCallback(() => {
+    dispatch({ type: 'reset' })
+  }, [])
+
+  return {
+    previewSession,
+    previewSessionsById: state.sessions,
+    activePreviewSessionId: state.activeSessionId,
+    hydratePreviewSessions,
+    upsertPreviewSession,
+    completePreviewSession,
+    removePreviewSession,
+    resetPreviewSessions,
+  }
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/home/types.ts b/apps/sim/app/workspace/[workspaceId]/home/types.ts
index e6ae3c9f0a9..5977f5e4720 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/types.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/types.ts
@@ -1,10 +1,40 @@
-import type { MothershipResourceType } from '@/lib/copilot/resource-types'
+import {
+  Agent,
+  Auth,
+  CreateWorkflow,
+  Deploy,
+  EditWorkflow,
+  FunctionExecute,
+  GetPageContents,
+  Glob,
+  Grep,
+  Job,
+  Knowledge,
+  KnowledgeBase,
+  ManageMcpTool,
+  ManageSkill,
+  OpenResource,
+  Read as ReadTool,
+  Research,
+  ScrapePage,
+  SearchLibraryDocs,
+  SearchOnline,
+  Superagent,
+  Table,
+  UserMemory,
+  UserTable,
+  Workflow,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import type { ChatContext } from '@/stores/panel'
 
+const EDIT_CONTENT_TOOL_ID = 'edit_content'
+const RUN_SUBAGENT_ID = 'run'
+
 export type {
   MothershipResource,
   MothershipResourceType,
-} from '@/lib/copilot/resource-types'
+} from '@/lib/copilot/resources/types'
 
 /** Union of all valid context kind strings, derived from {@link ChatContext}. */
 export type ChatContextKind = ChatContext['kind']
@@ -24,169 +54,34 @@ export interface QueuedMessage {
   contexts?: ChatContext[]
 }
 
-/**
- * SSE event types emitted by the Go orchestrator backend.
- *
- * @example
- * ```json
- * { "type": "content", "data": "Hello world" }
- * { "type": "tool_call", "state": "executing", "toolCallId": "toolu_...", "toolName": "glob", "ui": { "title": "..." } }
- * { "type": "subagent_start", "subagent": "build" }
- * ```
- */
-export type SSEEventType =
-  | 'chat_id'
-  | 'request_id'
-  | 'title_updated'
-  | 'content'
-  | 'reasoning' // openai reasoning - render as thinking text
-  | 'tool_call' // tool call name
-  | 'tool_call_delta' // chunk of tool call
-  | 'tool_generating' // start a tool call
-  | 'tool_result' // tool call result
-  | 'tool_error' // tool call error
-  | 'resource_added' // add a resource to the chat
-  | 'resource_deleted' // delete a resource from the chat
-  | 'subagent_start' // start a subagent
-  | 'subagent_end' // end a subagent
-  | 'structured_result' // structured result from a tool call
-  | 'subagent_result' // result from a subagent
-  | 'done' // end of the chat
-  | 'context_compaction_start' // context compaction started
-  | 'context_compaction' // conversation context was compacted
-  | 'error' // error in the chat
-  | 'start' // start of the chat
-
 /**
  * All tool names observed in the mothership SSE stream, grouped by phase.
  *
  * @example
  * ```json
- * { "type": "tool_generating", "toolName": "glob" }
- * { "type": "tool_call", "toolName": "function_execute", "ui": { "title": "Running code", "icon": "code" } }
- * ```
- */
-export type MothershipToolName =
-  | 'glob'
-  | 'grep'
-  | 'read'
-  | 'search_online'
-  | 'scrape_page'
-  | 'get_page_contents'
-  | 'search_library_docs'
-  | 'manage_mcp_tool'
-  | 'manage_skill'
-  | 'manage_credential'
-  | 'manage_custom_tool'
-  | 'manage_job'
-  | 'user_memory'
-  | 'function_execute'
-  | 'superagent'
-  | 'user_table'
-  | 'workspace_file'
-  | 'create_workflow'
-  | 'delete_workflow'
-  | 'edit_workflow'
-  | 'rename_workflow'
-  | 'move_workflow'
-  | 'run_workflow'
-  | 'run_block'
-  | 'run_from_block'
-  | 'run_workflow_until_block'
-  | 'create_folder'
-  | 'delete_folder'
-  | 'move_folder'
-  | 'list_folders'
-  | 'list_user_workspaces'
-  | 'create_job'
-  | 'complete_job'
-  | 'update_job_history'
-  | 'job_respond'
-  | 'download_to_workspace_file'
-  | 'materialize_file'
-  | 'context_write'
-  | 'generate_image'
-  | 'generate_visualization'
-  | 'crawl_website'
-  | 'get_execution_summary'
-  | 'get_job_logs'
-  | 'get_deployment_version'
-  | 'revert_to_version'
-  | 'check_deployment_status'
-  | 'get_deployed_workflow_state'
-  | 'get_workflow_data'
-  | 'get_workflow_logs'
-  | 'get_block_outputs'
-  | 'get_block_upstream_references'
-  | 'set_global_workflow_variables'
-  | 'set_environment_variables'
-  | 'get_platform_actions'
-  | 'search_documentation'
-  | 'search_patterns'
-  | 'update_workspace_mcp_server'
-  | 'delete_workspace_mcp_server'
-  | 'create_workspace_mcp_server'
-  | 'list_workspace_mcp_servers'
-  | 'deploy_api'
-  | 'deploy_chat'
-  | 'deploy_mcp'
-  | 'redeploy'
-  | 'generate_api_key'
-  | 'oauth_get_auth_link'
-  | 'oauth_request_access'
-  | 'build'
-  | 'run'
-  | 'deploy'
-  | 'auth'
-  | 'knowledge'
-  | 'knowledge_base'
-  | 'table'
-  | 'job'
-  | 'agent'
-  | 'custom_tool'
-  | 'research'
-  | 'plan'
-  | 'debug'
-  | 'edit'
-  | 'fast_edit'
-  | 'open_resource'
-  | 'context_compaction'
-
-/**
- * Subagent identifiers dispatched via `subagent_start` SSE events.
- *
- * @example
- * ```json
- * { "type": "subagent_start", "subagent": "build" }
+ * { "type": "tool", "phase": "call", "toolName": "glob" }
+ * { "type": "tool", "phase": "call", "toolName": "function_execute", "ui": { "title": "Running code", "icon": "code" } }
  * ```
+ * Stream `type` is `MothershipStreamV1EventType.tool` (`mothership-stream-v1`) with `phase: 'call'`.
  */
-export type SubagentName =
-  | 'build'
-  | 'deploy'
-  | 'auth'
-  | 'research'
-  | 'knowledge'
-  | 'table'
-  | 'custom_tool'
-  | 'superagent'
-  | 'plan'
-  | 'debug'
-  | 'edit'
-  | 'fast_edit'
-  | 'run'
-  | 'agent'
-  | 'job'
-  | 'file_write'
 
-export type ToolPhase =
-  | 'workspace'
-  | 'search'
-  | 'management'
-  | 'execution'
-  | 'resource'
-  | 'subagent'
+export const ToolPhase = {
+  workspace: 'workspace',
+  search: 'search',
+  management: 'management',
+  execution: 'execution',
+  resource: 'resource',
+  subagent: 'subagent',
+} as const
+export type ToolPhase = (typeof ToolPhase)[keyof typeof ToolPhase]
 
-export type ToolCallStatus = 'executing' | 'success' | 'error' | 'cancelled'
+export const ToolCallStatus = {
+  executing: 'executing',
+  success: 'success',
+  error: 'error',
+  cancelled: 'cancelled',
+} as const
+export type ToolCallStatus = (typeof ToolCallStatus)[keyof typeof ToolCallStatus]
 
 export interface ToolCallResult {
   success: boolean
@@ -194,7 +89,6 @@ export interface ToolCallResult {
   error?: string
 }
 
-/** A single tool call result entry in the generic Results resource tab. */
 export interface GenericResourceEntry {
   toolCallId: string
   toolName: string
@@ -205,7 +99,6 @@ export interface GenericResourceEntry {
   result?: ToolCallResult
 }
 
-/** Accumulated feed of tool call results shown in the generic Results tab. */
 export interface GenericResourceData {
   entries: GenericResourceEntry[]
 }
@@ -228,7 +121,7 @@ export interface ToolCallInfo {
   phaseLabel?: string
   params?: Record<string, unknown>
   calledBy?: string
-  result?: { success: boolean; output?: unknown; error?: string }
+  result?: ToolCallResult
   streamingArgs?: string
 }
 
@@ -237,14 +130,17 @@ export interface OptionItem {
   label: string
 }
 
-export type ContentBlockType =
-  | 'text'
-  | 'tool_call'
-  | 'subagent'
-  | 'subagent_end'
-  | 'subagent_text'
-  | 'options'
-  | 'stopped'
+export const ContentBlockType = {
+  text: 'text',
+  tool_call: 'tool_call',
+  subagent: 'subagent',
+  subagent_end: 'subagent_end',
+  subagent_text: 'subagent_text',
+  subagent_thinking: 'subagent_thinking',
+  options: 'options',
+  stopped: 'stopped',
+} as const
+export type ContentBlockType = (typeof ContentBlockType)[keyof typeof ContentBlockType]
 
 export interface ContentBlock {
   type: ContentBlockType
@@ -283,23 +179,19 @@ export interface ChatMessage {
   requestId?: string
 }
 
-export const SUBAGENT_LABELS: Record<SubagentName, string> = {
-  build: 'Build agent',
-  deploy: 'Deploy agent',
-  auth: 'Integration agent',
-  research: 'Research agent',
-  knowledge: 'Knowledge agent',
-  table: 'Table agent',
-  custom_tool: 'Custom Tool agent',
+export const SUBAGENT_LABELS: Record<string, string> = {
+  workflow: 'Workflow Agent',
+  deploy: 'Deploy Agent',
+  auth: 'Auth Agent',
+  research: 'Research Agent',
+  knowledge: 'Knowledge Agent',
+  table: 'Table Agent',
+  custom_tool: 'Custom Tool Agent',
   superagent: 'Superagent',
-  plan: 'Plan agent',
-  debug: 'Debug agent',
-  edit: 'Edit agent',
-  fast_edit: 'Build agent',
-  run: 'Run agent',
-  agent: 'Agent manager',
-  job: 'Job agent',
-  file_write: 'File Write',
+  run: 'Run Agent',
+  agent: 'Tools Agent',
+  job: 'Job Agent',
+  file: 'File Agent',
 } as const
 
 export interface ToolUIMetadata {
@@ -309,206 +201,127 @@ export interface ToolUIMetadata {
 }
 
 /**
- * Primary UI metadata for tools observed in the SSE stream.
- * Maps tool IDs to human-readable display names shown in the chat.
- * This is the single source of truth — server-sent `ui.title` values are not used.
+ * Default UI metadata for tools observed in the SSE stream.
+ * The backend may send `ui` on some `MothershipStreamV1EventType.tool` payloads (`phase: 'call'`);
+ * this map provides fallback metadata when `ui` is absent.
  */
-export const TOOL_UI_METADATA: Record<MothershipToolName, ToolUIMetadata> = {
-  // Workspace
-  glob: { title: 'Searching workspace', phaseLabel: 'Workspace', phase: 'workspace' },
-  grep: { title: 'Searching workspace', phaseLabel: 'Workspace', phase: 'workspace' },
-  read: { title: 'Reading file', phaseLabel: 'Workspace', phase: 'workspace' },
-  // Search
-  search_online: { title: 'Searching online', phaseLabel: 'Search', phase: 'search' },
-  scrape_page: { title: 'Reading webpage', phaseLabel: 'Search', phase: 'search' },
-  get_page_contents: { title: 'Reading page', phaseLabel: 'Search', phase: 'search' },
-  search_library_docs: { title: 'Searching docs', phaseLabel: 'Search', phase: 'search' },
-  crawl_website: { title: 'Browsing website', phaseLabel: 'Search', phase: 'search' },
-  // Execution
-  function_execute: { title: 'Running code', phaseLabel: 'Code', phase: 'execution' },
-  superagent: { title: 'Taking action', phaseLabel: 'Action', phase: 'execution' },
-  run_workflow: { title: 'Running workflow', phaseLabel: 'Execution', phase: 'execution' },
-  run_block: { title: 'Running block', phaseLabel: 'Execution', phase: 'execution' },
-  run_from_block: { title: 'Running from block', phaseLabel: 'Execution', phase: 'execution' },
-  run_workflow_until_block: {
-    title: 'Running partial workflow',
-    phaseLabel: 'Execution',
-    phase: 'execution',
+export const TOOL_UI_METADATA: Record<string, ToolUIMetadata> = {
+  [Glob.id]: {
+    title: 'Finding files',
+    phaseLabel: 'Workspace',
+    phase: 'workspace',
   },
-  complete_job: { title: 'Completing job', phaseLabel: 'Execution', phase: 'execution' },
-  get_execution_summary: { title: 'Checking results', phaseLabel: 'Execution', phase: 'execution' },
-  get_job_logs: { title: 'Checking logs', phaseLabel: 'Execution', phase: 'execution' },
-  get_workflow_logs: { title: 'Checking logs', phaseLabel: 'Execution', phase: 'execution' },
-  get_workflow_data: { title: 'Loading workflow', phaseLabel: 'Execution', phase: 'execution' },
-  get_block_outputs: {
-    title: 'Checking block outputs',
-    phaseLabel: 'Execution',
-    phase: 'execution',
+  [Grep.id]: {
+    title: 'Searching',
+    phaseLabel: 'Workspace',
+    phase: 'workspace',
   },
-  get_block_upstream_references: {
-    title: 'Checking references',
-    phaseLabel: 'Execution',
-    phase: 'execution',
+  [ReadTool.id]: { title: 'Reading file', phaseLabel: 'Workspace', phase: 'workspace' },
+  [SearchOnline.id]: {
+    title: 'Searching online',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [ScrapePage.id]: {
+    title: 'Scraping page',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [GetPageContents.id]: {
+    title: 'Getting page contents',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [SearchLibraryDocs.id]: {
+    title: 'Searching library docs',
+    phaseLabel: 'Search',
+    phase: 'search',
+  },
+  [ManageMcpTool.id]: {
+    title: 'MCP server action',
+    phaseLabel: 'Management',
+    phase: 'management',
   },
-  get_deployed_workflow_state: {
-    title: 'Checking deployment',
-    phaseLabel: 'Execution',
+  [ManageSkill.id]: {
+    title: 'Skill action',
+    phaseLabel: 'Management',
+    phase: 'management',
+  },
+  [UserMemory.id]: {
+    title: 'Accessing memory',
+    phaseLabel: 'Management',
+    phase: 'management',
+  },
+  [FunctionExecute.id]: {
+    title: 'Running code',
+    phaseLabel: 'Code',
     phase: 'execution',
   },
-  check_deployment_status: {
-    title: 'Checking deployment',
-    phaseLabel: 'Execution',
+  [Superagent.id]: {
+    title: 'Executing action',
+    phaseLabel: 'Action',
     phase: 'execution',
   },
-  // Workflows & folders
-  create_workflow: { title: 'Creating workflow', phaseLabel: 'Resource', phase: 'resource' },
-  delete_workflow: { title: 'Deleting workflow', phaseLabel: 'Resource', phase: 'resource' },
-  edit_workflow: { title: 'Editing workflow', phaseLabel: 'Resource', phase: 'resource' },
-  rename_workflow: { title: 'Renaming workflow', phaseLabel: 'Resource', phase: 'resource' },
-  move_workflow: { title: 'Moving workflow', phaseLabel: 'Resource', phase: 'resource' },
-  create_folder: { title: 'Creating folder', phaseLabel: 'Resource', phase: 'resource' },
-  delete_folder: { title: 'Deleting folder', phaseLabel: 'Resource', phase: 'resource' },
-  move_folder: { title: 'Moving folder', phaseLabel: 'Resource', phase: 'resource' },
-  list_folders: { title: 'Browsing folders', phaseLabel: 'Resource', phase: 'resource' },
-  list_user_workspaces: { title: 'Browsing workspaces', phaseLabel: 'Resource', phase: 'resource' },
-  revert_to_version: { title: 'Restoring version', phaseLabel: 'Resource', phase: 'resource' },
-  get_deployment_version: {
-    title: 'Checking deployment',
+  [UserTable.id]: {
+    title: 'Managing table',
     phaseLabel: 'Resource',
     phase: 'resource',
   },
-  open_resource: { title: 'Opening resource', phaseLabel: 'Resource', phase: 'resource' },
-  // Files
-  workspace_file: { title: 'Working with files', phaseLabel: 'Resource', phase: 'resource' },
-  download_to_workspace_file: {
-    title: 'Downloading file',
+  [WorkspaceFile.id]: {
+    title: 'Editing file',
     phaseLabel: 'Resource',
     phase: 'resource',
   },
-  materialize_file: { title: 'Saving file', phaseLabel: 'Resource', phase: 'resource' },
-  generate_image: { title: 'Generating image', phaseLabel: 'Resource', phase: 'resource' },
-  generate_visualization: {
-    title: 'Generating visualization',
+  [EDIT_CONTENT_TOOL_ID]: {
+    title: 'Applying file content',
     phaseLabel: 'Resource',
     phase: 'resource',
   },
-  // Tables & knowledge
-  user_table: { title: 'Editing table', phaseLabel: 'Resource', phase: 'resource' },
-  knowledge_base: { title: 'Updating knowledge base', phaseLabel: 'Resource', phase: 'resource' },
-  // Jobs
-  create_job: { title: 'Creating job', phaseLabel: 'Resource', phase: 'resource' },
-  manage_job: { title: 'Updating job', phaseLabel: 'Management', phase: 'management' },
-  update_job_history: { title: 'Updating job', phaseLabel: 'Management', phase: 'management' },
-  job_respond: { title: 'Explaining job scheduled', phaseLabel: 'Execution', phase: 'execution' },
-  // Management
-  manage_mcp_tool: { title: 'Updating integration', phaseLabel: 'Management', phase: 'management' },
-  manage_skill: { title: 'Updating skill', phaseLabel: 'Management', phase: 'management' },
-  manage_credential: { title: 'Connecting account', phaseLabel: 'Management', phase: 'management' },
-  manage_custom_tool: { title: 'Updating tool', phaseLabel: 'Management', phase: 'management' },
-  update_workspace_mcp_server: {
-    title: 'Updating MCP server',
-    phaseLabel: 'Management',
-    phase: 'management',
-  },
-  delete_workspace_mcp_server: {
-    title: 'Removing MCP server',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [CreateWorkflow.id]: {
+    title: 'Creating workflow',
+    phaseLabel: 'Resource',
+    phase: 'resource',
   },
-  create_workspace_mcp_server: {
-    title: 'Creating MCP server',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [EditWorkflow.id]: {
+    title: 'Editing workflow',
+    phaseLabel: 'Resource',
+    phase: 'resource',
   },
-  list_workspace_mcp_servers: {
-    title: 'Browsing MCP servers',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Workflow.id]: { title: 'Workflow Agent', phaseLabel: 'Workflow', phase: 'subagent' },
+  [RUN_SUBAGENT_ID]: { title: 'Run Agent', phaseLabel: 'Run', phase: 'subagent' },
+  [Deploy.id]: { title: 'Deploy Agent', phaseLabel: 'Deploy', phase: 'subagent' },
+  [Auth.id]: {
+    title: 'Auth Agent',
+    phaseLabel: 'Auth',
+    phase: 'subagent',
   },
-  oauth_get_auth_link: {
-    title: 'Connecting account',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Knowledge.id]: {
+    title: 'Knowledge Agent',
+    phaseLabel: 'Knowledge',
+    phase: 'subagent',
   },
-  oauth_request_access: {
-    title: 'Connecting account',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [KnowledgeBase.id]: {
+    title: 'Managing knowledge base',
+    phaseLabel: 'Resource',
+    phase: 'resource',
   },
-  set_environment_variables: {
-    title: 'Updating environment',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Table.id]: { title: 'Table Agent', phaseLabel: 'Table', phase: 'subagent' },
+  [Job.id]: { title: 'Job Agent', phaseLabel: 'Job', phase: 'subagent' },
+  [Agent.id]: { title: 'Tools Agent', phaseLabel: 'Agent', phase: 'subagent' },
+  custom_tool: {
+    title: 'Creating tool',
+    phaseLabel: 'Tool',
+    phase: 'subagent',
   },
-  set_global_workflow_variables: {
-    title: 'Updating variables',
-    phaseLabel: 'Management',
-    phase: 'management',
+  [Research.id]: { title: 'Research Agent', phaseLabel: 'Research', phase: 'subagent' },
+  [OpenResource.id]: {
+    title: 'Opening resource',
+    phaseLabel: 'Resource',
+    phase: 'resource',
   },
-  get_platform_actions: { title: 'Loading actions', phaseLabel: 'Management', phase: 'management' },
-  search_documentation: { title: 'Searching docs', phaseLabel: 'Search', phase: 'search' },
-  search_patterns: { title: 'Searching patterns', phaseLabel: 'Search', phase: 'search' },
-  deploy_api: { title: 'Deploying API', phaseLabel: 'Deploy', phase: 'management' },
-  deploy_chat: { title: 'Deploying chat', phaseLabel: 'Deploy', phase: 'management' },
-  deploy_mcp: { title: 'Deploying MCP', phaseLabel: 'Deploy', phase: 'management' },
-  redeploy: { title: 'Redeploying', phaseLabel: 'Deploy', phase: 'management' },
-  generate_api_key: { title: 'Generating API key', phaseLabel: 'Deploy', phase: 'management' },
-  user_memory: { title: 'Updating memory', phaseLabel: 'Management', phase: 'management' },
-  context_write: { title: 'Writing notes', phaseLabel: 'Management', phase: 'management' },
   context_compaction: {
-    title: 'Optimizing context',
-    phaseLabel: 'Management',
+    title: 'Compacted context',
+    phaseLabel: 'Context',
     phase: 'management',
   },
-  // Subagents
-  build: { title: 'Building', phaseLabel: 'Build', phase: 'subagent' },
-  run: { title: 'Running', phaseLabel: 'Run', phase: 'subagent' },
-  deploy: { title: 'Deploying', phaseLabel: 'Deploy', phase: 'subagent' },
-  auth: { title: 'Connecting integration', phaseLabel: 'Auth', phase: 'subagent' },
-  knowledge: { title: 'Working with knowledge', phaseLabel: 'Knowledge', phase: 'subagent' },
-  table: { title: 'Working with tables', phaseLabel: 'Table', phase: 'subagent' },
-  job: { title: 'Working with jobs', phaseLabel: 'Job', phase: 'subagent' },
-  agent: { title: 'Taking action', phaseLabel: 'Agent', phase: 'subagent' },
-  custom_tool: { title: 'Creating tool', phaseLabel: 'Tool', phase: 'subagent' },
-  research: { title: 'Researching', phaseLabel: 'Research', phase: 'subagent' },
-  plan: { title: 'Planning', phaseLabel: 'Plan', phase: 'subagent' },
-  debug: { title: 'Debugging', phaseLabel: 'Debug', phase: 'subagent' },
-  edit: { title: 'Editing workflow', phaseLabel: 'Edit', phase: 'subagent' },
-  fast_edit: { title: 'Editing workflow', phaseLabel: 'Edit', phase: 'subagent' },
-}
-
-export interface SSEPayloadUI {
-  hidden?: boolean
-  title?: string
-  phaseLabel?: string
-  icon?: string
-  internal?: boolean
-  clientExecutable?: boolean
-}
-
-export interface SSEPayloadData {
-  name?: string
-  ui?: SSEPayloadUI
-  id?: string
-  agent?: string
-  partial?: boolean
-  arguments?: Record<string, unknown>
-  input?: Record<string, unknown>
-  result?: unknown
-  error?: string
-}
-
-export interface SSEPayload {
-  type: SSEEventType | (string & {})
-  chatId?: string
-  data?: string | SSEPayloadData
-  content?: string
-  toolCallId?: string
-  toolName?: string
-  ui?: SSEPayloadUI
-  success?: boolean
-  result?: unknown
-  error?: string
-  subagent?: string
-  resource?: { type: MothershipResourceType; id: string; title: string }
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/logs/components/index.ts b/apps/sim/app/workspace/[workspaceId]/logs/components/index.ts
index 1a907cfd896..3c0c5922adf 100644
--- a/apps/sim/app/workspace/[workspaceId]/logs/components/index.ts
+++ b/apps/sim/app/workspace/[workspaceId]/logs/components/index.ts
@@ -1,5 +1,5 @@
 export { Dashboard } from './dashboard'
-export { LogDetails } from './log-details'
+export { LogDetails, WorkflowOutputSection } from './log-details'
 export { ExecutionSnapshot } from './log-details/components/execution-snapshot'
 export { FileCards } from './log-details/components/file-download'
 export { TraceSpans } from './log-details/components/trace-spans'
diff --git a/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/index.ts b/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/index.ts
index 5d9685fdbd3..47078f505c1 100644
--- a/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/index.ts
+++ b/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/index.ts
@@ -1 +1 @@
-export { LogDetails } from './log-details'
+export { LogDetails, WorkflowOutputSection } from './log-details'
diff --git a/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/log-details.tsx b/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/log-details.tsx
index 963aba17143..3c8f4e499d1 100644
--- a/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/log-details.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/logs/components/log-details/log-details.tsx
@@ -45,7 +45,7 @@ import { MAX_LOG_DETAILS_WIDTH_RATIO, MIN_LOG_DETAILS_WIDTH } from '@/stores/log
 /**
  * Workflow Output section with code viewer, copy, search, and context menu functionality
  */
-const WorkflowOutputSection = memo(
+export const WorkflowOutputSection = memo(
   function WorkflowOutputSection({ output }: { output: Record<string, unknown> }) {
     const contentRef = useRef<HTMLDivElement>(null)
     const [copied, setCopied] = useState(false)
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/[section]/settings.tsx b/apps/sim/app/workspace/[workspaceId]/settings/[section]/settings.tsx
index b6f439635b9..f12a214fbad 100644
--- a/apps/sim/app/workspace/[workspaceId]/settings/[section]/settings.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/settings/[section]/settings.tsx
@@ -143,6 +143,13 @@ const Admin = dynamic(
     import('@/app/workspace/[workspaceId]/settings/components/admin/admin').then((m) => m.Admin),
   { loading: () => <AdminSkeleton /> }
 )
+const Mothership = dynamic(
+  () =>
+    import('@/app/workspace/[workspaceId]/settings/components/mothership/mothership').then(
+      (m) => m.Mothership
+    ),
+  { loading: () => <SettingsSectionSkeleton /> }
+)
 const RecentlyDeleted = dynamic(
   () =>
     import(
@@ -187,7 +194,9 @@ export function SettingsPage({ section }: SettingsPageProps) {
         ? 'general'
         : section === 'admin' && !sessionLoading && !isAdminRole
           ? 'general'
-          : section
+          : section === 'mothership' && !sessionLoading && !isAdminRole
+            ? 'general'
+            : section
 
   const label =
     allNavigationItems.find((item) => item.id === effectiveSection)?.label ?? effectiveSection
@@ -221,6 +230,7 @@ export function SettingsPage({ section }: SettingsPageProps) {
       {effectiveSection === 'inbox' && <Inbox />}
       {effectiveSection === 'recently-deleted' && <RecentlyDeleted />}
       {effectiveSection === 'admin' && <Admin />}
+      {effectiveSection === 'mothership' && <Mothership />}
     </div>
   )
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/components/mothership/mothership.tsx b/apps/sim/app/workspace/[workspaceId]/settings/components/mothership/mothership.tsx
new file mode 100644
index 00000000000..261f5c9b536
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/settings/components/mothership/mothership.tsx
@@ -0,0 +1,908 @@
+'use client'
+
+import { useCallback, useMemo, useState } from 'react'
+import { Badge, Button, Input as EmcnInput, Label, Skeleton } from '@/components/emcn'
+import { cn } from '@/lib/core/utils/cn'
+import {
+  type MothershipEnv,
+  useGenerateLicense,
+  useMothershipEnterpriseStats,
+  useMothershipLicenses,
+  useMothershipRequests,
+  useMothershipTrace,
+  useMothershipUserBreakdown,
+} from '@/hooks/queries/mothership-admin'
+
+type Tab = 'overview' | 'licenses' | 'enterprise' | 'traces'
+
+const TABS: { id: Tab; label: string }[] = [
+  { id: 'overview', label: 'Overview' },
+  { id: 'licenses', label: 'Licenses' },
+  { id: 'enterprise', label: 'Enterprise' },
+  { id: 'traces', label: 'Traces' },
+]
+
+const ENV_OPTIONS: { id: MothershipEnv; label: string }[] = [
+  { id: 'dev', label: 'Dev' },
+  { id: 'staging', label: 'Staging' },
+  { id: 'prod', label: 'Prod' },
+]
+
+function defaultTimeRange() {
+  const end = new Date()
+  const start = new Date()
+  start.setDate(start.getDate() - 7)
+  return {
+    start: start.toISOString().slice(0, 16),
+    end: end.toISOString().slice(0, 16),
+  }
+}
+
+function toRFC3339(local: string) {
+  if (!local) return ''
+  return new Date(local).toISOString()
+}
+
+function formatCost(cost: number) {
+  return `$${cost.toFixed(4)}`
+}
+
+function formatDate(d: string | null | undefined) {
+  if (!d) return '—'
+  return new Date(d).toLocaleString()
+}
+
+function Divider() {
+  return <div className='h-px bg-[var(--border-secondary)]' />
+}
+
+function SectionLabel({ children }: { children: React.ReactNode }) {
+  return <p className='font-medium text-[var(--text-primary)] text-sm'>{children}</p>
+}
+
+export function Mothership() {
+  const [activeTab, setActiveTab] = useState<Tab>('overview')
+  const [environment, setEnvironment] = useState<MothershipEnv>('dev')
+  const defaults = useMemo(() => defaultTimeRange(), [])
+  const [start, setStart] = useState(defaults.start)
+  const [end, setEnd] = useState(defaults.end)
+
+  return (
+    <div className='flex h-full flex-col gap-5'>
+      {/* Environment selector */}
+      <div className='flex items-center gap-2'>
+        <Label className='text-[var(--text-secondary)] text-sm'>Environment</Label>
+        <div className='flex gap-1'>
+          {ENV_OPTIONS.map((opt) => (
+            <button
+              key={opt.id}
+              type='button'
+              onClick={() => setEnvironment(opt.id)}
+              className={cn(
+                'rounded-md px-3 py-1 font-medium text-sm transition-colors',
+                environment === opt.id
+                  ? 'bg-[var(--surface-hover)] text-[var(--text-primary)]'
+                  : 'text-[var(--text-tertiary)] hover-hover:hover:text-[var(--text-secondary)]'
+              )}
+            >
+              {opt.label}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* Tab bar */}
+      <div className='flex gap-1 border-[var(--border-secondary)] border-b pb-px'>
+        {TABS.map((tab) => (
+          <button
+            key={tab.id}
+            type='button'
+            onClick={() => setActiveTab(tab.id)}
+            className={cn(
+              'relative px-3 py-2 font-medium text-sm transition-colors',
+              activeTab === tab.id
+                ? 'text-[var(--text-primary)]'
+                : 'text-[var(--text-tertiary)] hover-hover:hover:text-[var(--text-secondary)]'
+            )}
+          >
+            {tab.label}
+            {activeTab === tab.id && (
+              <span className='absolute right-0 bottom-0 left-0 h-[2px] bg-[var(--text-primary)]' />
+            )}
+          </button>
+        ))}
+      </div>
+
+      {/* Time range (shared across tabs) */}
+      <div className='flex items-center gap-3'>
+        <div className='flex items-center gap-2'>
+          <Label className='text-[var(--text-secondary)] text-caption'>From</Label>
+          <EmcnInput
+            type='datetime-local'
+            value={start}
+            onChange={(e) => setStart(e.target.value)}
+            className='h-[30px] text-caption'
+          />
+        </div>
+        <div className='flex items-center gap-2'>
+          <Label className='text-[var(--text-secondary)] text-caption'>To</Label>
+          <EmcnInput
+            type='datetime-local'
+            value={end}
+            onChange={(e) => setEnd(e.target.value)}
+            className='h-[30px] text-caption'
+          />
+        </div>
+      </div>
+
+      <Divider />
+
+      {activeTab === 'overview' && (
+        <OverviewTab environment={environment} start={toRFC3339(start)} end={toRFC3339(end)} />
+      )}
+      {activeTab === 'licenses' && <LicensesTab environment={environment} />}
+      {activeTab === 'enterprise' && (
+        <EnterpriseTab environment={environment} start={toRFC3339(start)} end={toRFC3339(end)} />
+      )}
+      {activeTab === 'traces' && <TracesTab environment={environment} />}
+    </div>
+  )
+}
+
+/* ─── Overview Tab ─── */
+
+function OverviewTab({
+  environment,
+  start,
+  end,
+}: {
+  environment: MothershipEnv
+  start: string
+  end: string
+}) {
+  const { data: breakdown, isLoading: breakdownLoading } = useMothershipUserBreakdown(
+    environment,
+    start,
+    end
+  )
+  const { data: requests, isLoading: requestsLoading } = useMothershipRequests(
+    environment,
+    start,
+    end
+  )
+
+  return (
+    <div className='flex flex-col gap-5'>
+      {/* Summary cards */}
+      <div className='grid grid-cols-4 gap-3'>
+        <StatCard
+          label='Total Requests'
+          value={breakdown?.total_requests}
+          loading={breakdownLoading}
+        />
+        <StatCard label='Unique Users' value={breakdown?.total_users} loading={breakdownLoading} />
+        <StatCard
+          label='Total Cost'
+          value={
+            breakdown?.users
+              ? formatCost(
+                  breakdown.users.reduce(
+                    (s: number, u: { total_cost: number }) => s + u.total_cost,
+                    0
+                  )
+                )
+              : undefined
+          }
+          loading={breakdownLoading}
+        />
+        <StatCard
+          label='Avg Cost/Request'
+          value={
+            breakdown?.total_requests && breakdown.users
+              ? formatCost(
+                  breakdown.users.reduce(
+                    (s: number, u: { total_cost: number }) => s + u.total_cost,
+                    0
+                  ) / breakdown.total_requests
+                )
+              : undefined
+          }
+          loading={breakdownLoading}
+        />
+      </div>
+
+      {/* User breakdown */}
+      <SectionLabel>User Breakdown</SectionLabel>
+      {breakdownLoading && (
+        <div className='flex flex-col gap-2'>
+          {Array.from({ length: 5 }).map((_, i) => (
+            <Skeleton key={i} className='h-[36px] w-full rounded-md' />
+          ))}
+        </div>
+      )}
+      {breakdown?.users && (
+        <div className='flex flex-col gap-0.5'>
+          <div className='flex items-center gap-3 border-[var(--border-secondary)] border-b px-3 py-2 text-[var(--text-tertiary)] text-caption'>
+            <span className='flex-1'>User ID</span>
+            <span className='w-[100px] text-right'>Requests</span>
+            <span className='w-[100px] text-right'>Cost</span>
+            <span className='w-[160px] text-right'>Last Request</span>
+          </div>
+          {breakdown.users.map(
+            (u: {
+              user_id: string
+              request_count: number
+              total_cost: number
+              last_request: string
+            }) => (
+              <div
+                key={u.user_id}
+                className='flex items-center gap-3 border-[var(--border-secondary)] border-b px-3 py-2 text-small last:border-b-0'
+              >
+                <span className='flex-1 truncate font-mono text-[12px] text-[var(--text-primary)]'>
+                  {u.user_id}
+                </span>
+                <span className='w-[100px] text-right text-[var(--text-secondary)]'>
+                  {u.request_count}
+                </span>
+                <span className='w-[100px] text-right text-[var(--text-secondary)]'>
+                  {formatCost(u.total_cost)}
+                </span>
+                <span className='w-[160px] text-right text-[var(--text-tertiary)] text-caption'>
+                  {formatDate(u.last_request)}
+                </span>
+              </div>
+            )
+          )}
+        </div>
+      )}
+
+      {/* Recent requests */}
+      <Divider />
+      <SectionLabel>Recent Requests ({requests?.count ?? '…'})</SectionLabel>
+      {requestsLoading && (
+        <div className='flex flex-col gap-2'>
+          {Array.from({ length: 5 }).map((_, i) => (
+            <Skeleton key={i} className='h-[36px] w-full rounded-md' />
+          ))}
+        </div>
+      )}
+      {requests?.requests && (
+        <div className='max-h-[400px] overflow-auto'>
+          <div className='flex flex-col gap-0.5'>
+            <div className='sticky top-0 z-10 flex items-center gap-3 border-[var(--border-secondary)] border-b bg-[var(--surface-1)] px-3 py-2 text-[var(--text-tertiary)] text-caption'>
+              <span className='w-[180px]'>Request ID</span>
+              <span className='w-[80px]'>Model</span>
+              <span className='w-[80px] text-right'>Duration</span>
+              <span className='w-[80px] text-right'>Cost</span>
+              <span className='w-[60px] text-right'>Tools</span>
+              <span className='w-[70px] text-right'>Status</span>
+              <span className='flex-1 text-right'>Time</span>
+            </div>
+            {requests.requests
+              .slice(0, 100)
+              .map(
+                (r: {
+                  request_id: string
+                  model: string
+                  duration_ms: number
+                  billed_total_cost: number
+                  tool_call_count: number
+                  error: boolean
+                  aborted: boolean
+                  created_at: string
+                }) => (
+                  <div
+                    key={r.request_id}
+                    className='flex items-center gap-3 border-[var(--border-secondary)] border-b px-3 py-1.5 text-small last:border-b-0'
+                  >
+                    <span className='w-[180px] truncate font-mono text-[11px] text-[var(--text-primary)]'>
+                      {r.request_id ?? '—'}
+                    </span>
+                    <span className='w-[80px] truncate text-[var(--text-secondary)] text-caption'>
+                      {(r.model ?? '').replace('claude-', '')}
+                    </span>
+                    <span className='w-[80px] text-right text-[var(--text-secondary)] text-caption'>
+                      {r.duration_ms ? `${(r.duration_ms / 1000).toFixed(1)}s` : '—'}
+                    </span>
+                    <span className='w-[80px] text-right text-[var(--text-secondary)] text-caption'>
+                      {formatCost(r.billed_total_cost ?? 0)}
+                    </span>
+                    <span className='w-[60px] text-right text-[var(--text-secondary)] text-caption'>
+                      {r.tool_call_count ?? 0}
+                    </span>
+                    <span className='w-[70px] text-right'>
+                      {r.error ? (
+                        <Badge variant='red'>Error</Badge>
+                      ) : r.aborted ? (
+                        <Badge variant='amber'>Abort</Badge>
+                      ) : (
+                        <Badge variant='green'>OK</Badge>
+                      )}
+                    </span>
+                    <span className='flex-1 text-right text-[var(--text-tertiary)] text-caption'>
+                      {formatDate(r.created_at)}
+                    </span>
+                  </div>
+                )
+              )}
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+/* ─── Licenses Tab ─── */
+
+function LicensesTab({ environment }: { environment: MothershipEnv }) {
+  const { data, isLoading, refetch } = useMothershipLicenses(environment)
+  const generateLicense = useGenerateLicense(environment)
+  const [newName, setNewName] = useState('')
+  const [newExpiry, setNewExpiry] = useState('')
+  const [generatedKey, setGeneratedKey] = useState<string | null>(null)
+
+  const handleGenerate = useCallback(() => {
+    if (!newName.trim()) return
+    generateLicense.mutate(
+      {
+        name: newName.trim(),
+        ...(newExpiry ? { expirationDate: newExpiry } : {}),
+      },
+      {
+        onSuccess: (result) => {
+          setGeneratedKey(result.license_key)
+          setNewName('')
+          setNewExpiry('')
+          refetch()
+        },
+      }
+    )
+  }, [newName, newExpiry, generateLicense, refetch])
+
+  return (
+    <div className='flex flex-col gap-5'>
+      <SectionLabel>Generate License</SectionLabel>
+      <div className='flex items-end gap-2'>
+        <div className='flex flex-col gap-1'>
+          <Label className='text-[var(--text-secondary)] text-caption'>Enterprise Name</Label>
+          <EmcnInput
+            value={newName}
+            onChange={(e) => {
+              setNewName(e.target.value)
+              setGeneratedKey(null)
+            }}
+            placeholder='e.g. Acme Corp'
+            className='h-[32px] w-[200px]'
+          />
+        </div>
+        <div className='flex flex-col gap-1'>
+          <Label className='text-[var(--text-secondary)] text-caption'>Expiration (optional)</Label>
+          <EmcnInput
+            type='date'
+            value={newExpiry}
+            onChange={(e) => setNewExpiry(e.target.value)}
+            className='h-[32px] w-[160px]'
+          />
+        </div>
+        <Button
+          variant='primary'
+          className='h-[32px]'
+          onClick={handleGenerate}
+          disabled={generateLicense.isPending || !newName.trim()}
+        >
+          {generateLicense.isPending ? 'Generating...' : 'Generate'}
+        </Button>
+      </div>
+
+      {generatedKey && (
+        <div className='rounded-md border border-[var(--border-secondary)] bg-[var(--surface-hover)] p-3'>
+          <p className='mb-1 text-[var(--text-secondary)] text-caption'>
+            License key (only shown once):
+          </p>
+          <code className='block break-all font-mono text-[12px] text-[var(--text-primary)]'>
+            {generatedKey}
+          </code>
+        </div>
+      )}
+
+      {generateLicense.error && (
+        <p className='text-[var(--text-error)] text-small'>{generateLicense.error.message}</p>
+      )}
+
+      <Divider />
+      <SectionLabel>All Licenses</SectionLabel>
+
+      {isLoading && (
+        <div className='flex flex-col gap-2'>
+          {Array.from({ length: 3 }).map((_, i) => (
+            <Skeleton key={i} className='h-[40px] w-full rounded-md' />
+          ))}
+        </div>
+      )}
+
+      {data?.licenses && (
+        <div className='flex flex-col gap-0.5'>
+          <div className='flex items-center gap-3 border-[var(--border-secondary)] border-b px-3 py-2 text-[var(--text-tertiary)] text-caption'>
+            <span className='flex-1'>Name</span>
+            <span className='w-[100px] text-right'>Validations</span>
+            <span className='w-[140px] text-right'>Expiration</span>
+            <span className='w-[140px] text-right'>Created</span>
+          </div>
+          {data.licenses.length === 0 && (
+            <div className='py-4 text-center text-[var(--text-tertiary)] text-small'>
+              No licenses found.
+            </div>
+          )}
+          {data.licenses.map(
+            (lic: {
+              id: string
+              name: string
+              count: number
+              expiration_date?: string
+              created_at: string
+            }) => (
+              <div
+                key={lic.id}
+                className='flex items-center gap-3 border-[var(--border-secondary)] border-b px-3 py-2 text-small last:border-b-0'
+              >
+                <span className='flex-1 text-[var(--text-primary)]'>{lic.name}</span>
+                <span className='w-[100px] text-right text-[var(--text-secondary)]'>
+                  {lic.count}
+                </span>
+                <span className='w-[140px] text-right text-[var(--text-tertiary)] text-caption'>
+                  {lic.expiration_date ? formatDate(lic.expiration_date) : 'Never'}
+                </span>
+                <span className='w-[140px] text-right text-[var(--text-tertiary)] text-caption'>
+                  {formatDate(lic.created_at)}
+                </span>
+              </div>
+            )
+          )}
+        </div>
+      )}
+    </div>
+  )
+}
+
+/* ─── Enterprise Tab ─── */
+
+function EnterpriseTab({
+  environment,
+  start,
+  end,
+}: {
+  environment: MothershipEnv
+  start: string
+  end: string
+}) {
+  const [customerType, setCustomerType] = useState('')
+  const [searchInput, setSearchInput] = useState('')
+  const { data, isLoading, error } = useMothershipEnterpriseStats(
+    environment,
+    customerType,
+    start,
+    end
+  )
+
+  const handleSearch = () => {
+    setCustomerType(searchInput.trim())
+  }
+
+  return (
+    <div className='flex flex-col gap-5'>
+      <div className='flex items-center gap-2'>
+        <EmcnInput
+          value={searchInput}
+          onChange={(e) => setSearchInput(e.target.value)}
+          onKeyDown={(e) => e.key === 'Enter' && handleSearch()}
+          placeholder='Enter customer type (e.g. enterprise name)...'
+        />
+        <Button variant='primary' onClick={handleSearch} disabled={!searchInput.trim()}>
+          Search
+        </Button>
+      </div>
+
+      {error && <p className='text-[var(--text-error)] text-small'>{error.message}</p>}
+
+      {isLoading && customerType && (
+        <div className='flex flex-col gap-2'>
+          {Array.from({ length: 4 }).map((_, i) => (
+            <Skeleton key={i} className='h-[60px] w-full rounded-md' />
+          ))}
+        </div>
+      )}
+
+      {data && (
+        <>
+          <div className='grid grid-cols-4 gap-3'>
+            <StatCard label='Total Requests' value={data.total_requests} />
+            <StatCard label='Unique Users' value={data.unique_users} />
+            <StatCard label='Total Cost' value={formatCost(data.total_cost ?? 0)} />
+            <StatCard
+              label='Total Tokens'
+              value={(
+                (data.total_input_tokens ?? 0) + (data.total_output_tokens ?? 0)
+              ).toLocaleString()}
+            />
+          </div>
+
+          {data.top_models && (
+            <>
+              <Divider />
+              <SectionLabel>Top Models</SectionLabel>
+              <div className='flex flex-wrap gap-2'>
+                {data.top_models.map((m: { model: string; count: number }) => (
+                  <Badge key={m.model} variant='gray'>
+                    {m.model} ({m.count})
+                  </Badge>
+                ))}
+              </div>
+            </>
+          )}
+
+          {data.users && (
+            <>
+              <Divider />
+              <SectionLabel>User Breakdown</SectionLabel>
+              <div className='flex flex-col gap-0.5'>
+                <div className='flex items-center gap-3 border-[var(--border-secondary)] border-b px-3 py-2 text-[var(--text-tertiary)] text-caption'>
+                  <span className='flex-1'>User ID</span>
+                  <span className='w-[100px] text-right'>Requests</span>
+                  <span className='w-[100px] text-right'>Cost</span>
+                  <span className='w-[160px] text-right'>Last Request</span>
+                </div>
+                {data.users.map(
+                  (u: {
+                    user_id: string
+                    request_count: number
+                    total_cost: number
+                    last_request: string
+                  }) => (
+                    <div
+                      key={u.user_id}
+                      className='flex items-center gap-3 border-[var(--border-secondary)] border-b px-3 py-2 text-small last:border-b-0'
+                    >
+                      <span className='flex-1 truncate font-mono text-[12px] text-[var(--text-primary)]'>
+                        {u.user_id}
+                      </span>
+                      <span className='w-[100px] text-right text-[var(--text-secondary)]'>
+                        {u.request_count}
+                      </span>
+                      <span className='w-[100px] text-right text-[var(--text-secondary)]'>
+                        {formatCost(u.total_cost)}
+                      </span>
+                      <span className='w-[160px] text-right text-[var(--text-tertiary)] text-caption'>
+                        {formatDate(u.last_request)}
+                      </span>
+                    </div>
+                  )
+                )}
+              </div>
+            </>
+          )}
+        </>
+      )}
+    </div>
+  )
+}
+
+/* ─── Traces Tab ─── */
+
+function TracesTab({ environment }: { environment: MothershipEnv }) {
+  const [requestIdInput, setRequestIdInput] = useState('')
+  const [activeRequestId, setActiveRequestId] = useState('')
+  const { data: trace, isLoading, error } = useMothershipTrace(environment, activeRequestId)
+
+  const handleLookup = () => {
+    setActiveRequestId(requestIdInput.trim())
+  }
+
+  return (
+    <div className='flex flex-col gap-5'>
+      <div className='flex items-center gap-2'>
+        <EmcnInput
+          value={requestIdInput}
+          onChange={(e) => setRequestIdInput(e.target.value)}
+          onKeyDown={(e) => e.key === 'Enter' && handleLookup()}
+          placeholder='Paste a request ID (sim_request_id)...'
+          className='font-mono text-[13px]'
+        />
+        <Button variant='primary' onClick={handleLookup} disabled={!requestIdInput.trim()}>
+          Lookup
+        </Button>
+      </div>
+
+      {error && <p className='text-[var(--text-error)] text-small'>{error.message}</p>}
+
+      {isLoading && activeRequestId && (
+        <div className='flex flex-col gap-2'>
+          {Array.from({ length: 4 }).map((_, i) => (
+            <Skeleton key={i} className='h-[50px] w-full rounded-md' />
+          ))}
+        </div>
+      )}
+
+      {trace && <TraceDetail trace={trace} />}
+    </div>
+  )
+}
+
+/* ─── Trace Detail ─── */
+
+interface TraceSpan {
+  name: string
+  kind?: string
+  startMs: number
+  endMs?: number
+  durationMs?: number
+  status: string
+  parentName?: string
+  source?: string
+  attributes?: Record<string, unknown>
+}
+
+interface TraceData {
+  id: string
+  simRequestId: string
+  goTraceId: string
+  streamId?: string
+  chatId?: string
+  userId?: string
+  startMs: number
+  endMs: number
+  durationMs: number
+  outcome: string
+  spans: TraceSpan[]
+  model?: string
+  provider?: string
+  mode?: string
+  source?: string
+  message?: string
+  inputTokens?: number
+  outputTokens?: number
+  cacheReadTokens?: number
+  cacheWriteTokens?: number
+  rawTotalCost?: number
+  billedTotalCost?: number
+  toolCallCount?: number
+  error?: boolean
+  aborted?: boolean
+  errorMsg?: string
+}
+
+function TraceDetail({ trace }: { trace: TraceData }) {
+  const rootSpans = trace.spans.filter((s) => !s.parentName)
+  const childMap = new Map<string, TraceSpan[]>()
+  for (const span of trace.spans) {
+    if (span.parentName) {
+      const existing = childMap.get(span.parentName) || []
+      existing.push(span)
+      childMap.set(span.parentName, existing)
+    }
+  }
+
+  return (
+    <div className='flex flex-col gap-4'>
+      {/* Trace metadata */}
+      <div className='grid grid-cols-2 gap-x-6 gap-y-2 rounded-md border border-[var(--border-secondary)] p-4'>
+        <MetaRow label='Go Trace ID' value={trace.goTraceId} mono />
+        <MetaRow label='Sim Request ID' value={trace.simRequestId} mono />
+        <MetaRow label='Outcome'>
+          <Badge
+            variant={
+              trace.outcome === 'success'
+                ? 'green'
+                : trace.outcome === 'cancelled'
+                  ? 'amber'
+                  : 'red'
+            }
+          >
+            {trace.outcome}
+          </Badge>
+        </MetaRow>
+        <MetaRow label='Duration' value={`${(trace.durationMs / 1000).toFixed(2)}s`} />
+        <MetaRow label='Model' value={trace.model || '—'} />
+        <MetaRow label='Provider' value={trace.provider || '—'} />
+        <MetaRow label='Source' value={trace.source || '—'} />
+        <MetaRow label='Mode' value={trace.mode || '—'} />
+        {trace.userId && <MetaRow label='User ID' value={trace.userId} mono />}
+        {trace.chatId && <MetaRow label='Chat ID' value={trace.chatId} mono />}
+        <MetaRow
+          label='Tokens'
+          value={`${(trace.inputTokens ?? 0).toLocaleString()} in / ${(trace.outputTokens ?? 0).toLocaleString()} out`}
+        />
+        <MetaRow label='Billed Cost' value={formatCost(trace.billedTotalCost ?? 0)} />
+        {trace.toolCallCount != null && trace.toolCallCount > 0 && (
+          <MetaRow label='Tool Calls' value={String(trace.toolCallCount)} />
+        )}
+        {trace.message && (
+          <div className='col-span-2'>
+            <MetaRow label='Message' value={trace.message} />
+          </div>
+        )}
+        {trace.errorMsg && (
+          <div className='col-span-2'>
+            <MetaRow label='Error'>
+              <span className='text-[var(--text-error)]'>{trace.errorMsg}</span>
+            </MetaRow>
+          </div>
+        )}
+      </div>
+
+      {/* Span tree */}
+      <SectionLabel>Spans ({trace.spans.length})</SectionLabel>
+      <div className='flex flex-col gap-1'>
+        {rootSpans
+          .sort((a, b) => a.startMs - b.startMs)
+          .map((span) => (
+            <SpanNode
+              key={span.name + span.startMs}
+              span={span}
+              childMap={childMap}
+              traceStartMs={trace.startMs}
+              traceDurationMs={trace.durationMs}
+              depth={0}
+            />
+          ))}
+      </div>
+    </div>
+  )
+}
+
+function SpanNode({
+  span,
+  childMap,
+  traceStartMs,
+  traceDurationMs,
+  depth,
+}: {
+  span: TraceSpan
+  childMap: Map<string, TraceSpan[]>
+  traceStartMs: number
+  traceDurationMs: number
+  depth: number
+}) {
+  const [expanded, setExpanded] = useState(depth < 2)
+  const children = childMap.get(span.name) || []
+  const hasChildren = children.length > 0
+  const durationMs = span.durationMs ?? (span.endMs ? span.endMs - span.startMs : 0)
+  const offsetPct =
+    traceDurationMs > 0 ? ((span.startMs - traceStartMs) / traceDurationMs) * 100 : 0
+  const widthPct = traceDurationMs > 0 ? (durationMs / traceDurationMs) * 100 : 0
+
+  const statusColor =
+    span.status === 'ok'
+      ? 'bg-emerald-500/70'
+      : span.status === 'error'
+        ? 'bg-red-500/70'
+        : span.status === 'cancelled'
+          ? 'bg-yellow-500/70'
+          : 'bg-[var(--text-tertiary)]'
+
+  const attrs = span.attributes || {}
+  const attrEntries = Object.entries(attrs).filter(
+    ([, v]) => v !== null && v !== undefined && v !== ''
+  )
+
+  return (
+    <div style={{ marginLeft: depth * 16 }}>
+      <button
+        type='button'
+        onClick={() => setExpanded((e) => !e)}
+        className='flex w-full items-center gap-2 rounded-md px-2 py-1.5 text-left transition-colors hover-hover:hover:bg-[var(--surface-hover)]'
+      >
+        {hasChildren ? (
+          <span className='w-[14px] text-center text-[10px] text-[var(--text-tertiary)]'>
+            {expanded ? '▼' : '▶'}
+          </span>
+        ) : (
+          <span className='w-[14px]' />
+        )}
+
+        <span className='min-w-0 flex-1'>
+          <span className='block truncate text-[13px] text-[var(--text-primary)]'>{span.name}</span>
+          {/* Waterfall bar */}
+          <span className='mt-0.5 block h-[4px] w-full rounded-full bg-[var(--border-secondary)]'>
+            <span
+              className={cn('block h-full rounded-full', statusColor)}
+              style={{
+                marginLeft: `${Math.max(0, Math.min(offsetPct, 100))}%`,
+                width: `${Math.max(0.5, Math.min(widthPct, 100 - offsetPct))}%`,
+              }}
+            />
+          </span>
+        </span>
+
+        <Badge variant={span.source === 'go' ? 'blue' : 'gray'} className='shrink-0'>
+          {span.source || '?'}
+        </Badge>
+
+        <span className='w-[70px] shrink-0 text-right font-mono text-[11px] text-[var(--text-secondary)]'>
+          {durationMs >= 1000 ? `${(durationMs / 1000).toFixed(2)}s` : `${durationMs}ms`}
+        </span>
+      </button>
+
+      {expanded && attrEntries.length > 0 && (
+        <div
+          className='mb-1 ml-[30px] rounded border border-[var(--border-secondary)] bg-[var(--surface-hover)] px-3 py-2'
+          style={{ marginLeft: 30 + depth * 16 }}
+        >
+          {attrEntries.map(([key, val]) => (
+            <div key={key} className='flex gap-2 py-0.5 text-[11px]'>
+              <span className='shrink-0 text-[var(--text-tertiary)]'>{key}:</span>
+              <span className='min-w-0 break-all text-[var(--text-secondary)]'>
+                {typeof val === 'object' ? JSON.stringify(val) : String(val)}
+              </span>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {expanded &&
+        children
+          .sort((a, b) => a.startMs - b.startMs)
+          .map((child) => (
+            <SpanNode
+              key={child.name + child.startMs}
+              span={child}
+              childMap={childMap}
+              traceStartMs={traceStartMs}
+              traceDurationMs={traceDurationMs}
+              depth={depth + 1}
+            />
+          ))}
+    </div>
+  )
+}
+
+/* ─── Shared components ─── */
+
+function StatCard({
+  label,
+  value,
+  loading,
+}: {
+  label: string
+  value?: string | number
+  loading?: boolean
+}) {
+  return (
+    <div className='rounded-md border border-[var(--border-secondary)] p-3'>
+      <p className='text-[var(--text-tertiary)] text-caption'>{label}</p>
+      {loading ? (
+        <Skeleton className='mt-1 h-[24px] w-[80px] rounded-sm' />
+      ) : (
+        <p className='mt-1 font-medium text-[18px] text-[var(--text-primary)]'>{value ?? '—'}</p>
+      )}
+    </div>
+  )
+}
+
+function MetaRow({
+  label,
+  value,
+  mono,
+  children,
+}: {
+  label: string
+  value?: string
+  mono?: boolean
+  children?: React.ReactNode
+}) {
+  return (
+    <div className='flex items-baseline gap-2'>
+      <span className='shrink-0 text-[var(--text-tertiary)] text-caption'>{label}</span>
+      {children || (
+        <span
+          className={cn(
+            'min-w-0 break-all text-[13px] text-[var(--text-primary)]',
+            mono && 'font-mono text-[12px]'
+          )}
+        >
+          {value}
+        </span>
+      )}
+    </div>
+  )
+}
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/navigation.ts b/apps/sim/app/workspace/[workspaceId]/settings/navigation.ts
index ff25389fc0c..0ef8ef67dac 100644
--- a/apps/sim/app/workspace/[workspaceId]/settings/navigation.ts
+++ b/apps/sim/app/workspace/[workspaceId]/settings/navigation.ts
@@ -42,6 +42,7 @@ export type SettingsSection =
   | 'workflow-mcp-servers'
   | 'inbox'
   | 'admin'
+  | 'mothership'
   | 'recently-deleted'
 
 export type NavigationSection =
@@ -190,4 +191,11 @@ export const allNavigationItems: NavigationItem[] = [
     section: 'superuser',
     requiresAdminRole: true,
   },
+  {
+    id: 'mothership',
+    label: 'Mothership',
+    icon: Server,
+    section: 'superuser',
+    requiresAdminRole: true,
+  },
 ]
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/note-block/note-block.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/note-block/note-block.tsx
index fd9b6b2cf92..65f002c9ccd 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/note-block/note-block.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/note-block/note-block.tsx
@@ -1,8 +1,8 @@
 import { memo, useCallback, useMemo } from 'react'
-import ReactMarkdown from 'react-markdown'
 import type { NodeProps } from 'reactflow'
 import remarkBreaks from 'remark-breaks'
-import remarkGfm from 'remark-gfm'
+import { Streamdown } from 'streamdown'
+import 'streamdown/styles.css'
 import { cn } from '@/lib/core/utils/cn'
 import { BLOCK_DIMENSIONS } from '@/lib/workflows/blocks/block-dimensions'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
@@ -303,174 +303,161 @@ function getEmbedInfo(url: string): EmbedInfo | null {
 /**
  * Compact markdown renderer for note blocks with tight spacing
  */
-const NoteMarkdown = memo(function NoteMarkdown({ content }: { content: string }) {
-  return (
-    <ReactMarkdown
-      remarkPlugins={[remarkGfm, remarkBreaks]}
-      components={{
-        p: ({ children }: any) => (
-          <p className='mb-1 break-words text-[var(--text-primary)] text-sm leading-[1.25rem] last:mb-0'>
-            {children}
-          </p>
-        ),
-        h1: ({ children }: any) => (
-          <h1 className='mt-3 mb-3 break-words font-semibold text-[var(--text-primary)] text-lg first:mt-0'>
-            {children}
-          </h1>
-        ),
-        h2: ({ children }: any) => (
-          <h2 className='mt-2.5 mb-2.5 break-words font-semibold text-[var(--text-primary)] text-base first:mt-0'>
-            {children}
-          </h2>
-        ),
-        h3: ({ children }: any) => (
-          <h3 className='mt-2 mb-2 break-words font-semibold text-[var(--text-primary)] text-sm first:mt-0'>
-            {children}
-          </h3>
-        ),
-        h4: ({ children }: any) => (
-          <h4 className='mt-2 mb-2 break-words font-semibold text-[var(--text-primary)] text-xs first:mt-0'>
-            {children}
-          </h4>
-        ),
-        ul: ({ children }: any) => (
-          <ul className='mt-1 mb-1 list-disc space-y-1 break-words pl-6 text-[var(--text-primary)] text-sm'>
-            {children}
-          </ul>
-        ),
-        ol: ({ children }: any) => (
-          <ol className='mt-1 mb-1 list-decimal space-y-1 break-words pl-6 text-[var(--text-primary)] text-sm'>
+const NOTE_REMARK_PLUGINS = [remarkBreaks]
+
+const NOTE_COMPONENTS = {
+  p: ({ children }: { children?: React.ReactNode }) => (
+    <p className='mb-1 break-words text-[var(--text-primary)] text-sm leading-[1.25rem] last:mb-0'>
+      {children}
+    </p>
+  ),
+  h1: ({ children }: { children?: React.ReactNode }) => (
+    <h1 className='mt-3 mb-3 break-words font-semibold text-[var(--text-primary)] text-lg first:mt-0'>
+      {children}
+    </h1>
+  ),
+  h2: ({ children }: { children?: React.ReactNode }) => (
+    <h2 className='mt-2.5 mb-2.5 break-words font-semibold text-[var(--text-primary)] text-base first:mt-0'>
+      {children}
+    </h2>
+  ),
+  h3: ({ children }: { children?: React.ReactNode }) => (
+    <h3 className='mt-2 mb-2 break-words font-semibold text-[var(--text-primary)] text-sm first:mt-0'>
+      {children}
+    </h3>
+  ),
+  h4: ({ children }: { children?: React.ReactNode }) => (
+    <h4 className='mt-2 mb-2 break-words font-semibold text-[var(--text-primary)] text-xs first:mt-0'>
+      {children}
+    </h4>
+  ),
+  ul: ({ children }: { children?: React.ReactNode }) => (
+    <ul className='mt-1 mb-1 list-disc space-y-1 break-words pl-6 text-[var(--text-primary)] text-sm'>
+      {children}
+    </ul>
+  ),
+  ol: ({ children }: { children?: React.ReactNode }) => (
+    <ol className='mt-1 mb-1 list-decimal space-y-1 break-words pl-6 text-[var(--text-primary)] text-sm'>
+      {children}
+    </ol>
+  ),
+  li: ({ children }: { children?: React.ReactNode }) => <li className='break-words'>{children}</li>,
+  inlineCode: ({ children }: { children?: React.ReactNode }) => (
+    <code className='whitespace-normal rounded bg-[var(--surface-5)] px-1 py-0.5 font-mono text-[var(--caution)] text-xs'>
+      {children}
+    </code>
+  ),
+  code: ({ children, className, ...props }: { children?: React.ReactNode; className?: string }) => (
+    <code
+      {...props}
+      className='block whitespace-pre-wrap break-words rounded bg-[var(--surface-5)] p-2 text-[var(--text-primary)] text-xs'
+    >
+      {children}
+    </code>
+  ),
+  a: ({ href, children }: { href?: string; children?: React.ReactNode }) => {
+    const embedInfo = href ? getEmbedInfo(href) : null
+    if (embedInfo) {
+      return (
+        <span className='my-2 block w-full'>
+          <a
+            href={href}
+            target='_blank'
+            rel='noopener noreferrer'
+            className='mb-1 block break-all text-[var(--brand-secondary)] underline-offset-2 hover-hover:underline'
+          >
             {children}
-          </ol>
-        ),
-        li: ({ children }: any) => <li className='break-words'>{children}</li>,
-        code: ({ inline, className, children, ...props }: any) => {
-          const isInline = inline || !className?.includes('language-')
-
-          if (isInline) {
-            return (
-              <code
-                {...props}
-                className='whitespace-normal rounded bg-[var(--surface-5)] px-1 py-0.5 font-mono text-[var(--caution)] text-xs'
+          </a>
+          <span className='block w-full overflow-hidden rounded-md'>
+            {embedInfo.type === 'iframe' && (
+              <span
+                className='block overflow-hidden'
+                style={{
+                  width: '100%',
+                  aspectRatio: embedInfo.aspectRatio || '16/9',
+                }}
               >
-                {children}
-              </code>
-            )
-          }
-
-          return (
-            <code
-              {...props}
-              className='block whitespace-pre-wrap break-words rounded bg-[var(--surface-5)] p-2 text-[var(--text-primary)] text-xs'
-            >
-              {children}
-            </code>
-          )
-        },
-        a: ({ href, children }: any) => {
-          const embedInfo = href ? getEmbedInfo(href) : null
-          if (embedInfo) {
-            return (
-              <span className='my-2 block w-full'>
-                <a
-                  href={href}
-                  target='_blank'
-                  rel='noopener noreferrer'
-                  className='mb-1 block break-all text-[var(--brand-secondary)] underline-offset-2 hover-hover:underline'
-                >
-                  {children}
-                </a>
-                <span className='block w-full overflow-hidden rounded-md'>
-                  {embedInfo.type === 'iframe' && (
-                    <span
-                      className='block overflow-hidden'
-                      style={{
-                        width: '100%',
-                        aspectRatio: embedInfo.aspectRatio || '16/9',
-                      }}
-                    >
-                      <iframe
-                        src={embedInfo.url}
-                        title='Media'
-                        allow='accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share'
-                        allowFullScreen
-                        loading='lazy'
-                        className='origin-top-left'
-                        style={{
-                          width: EMBED_INVERSE_SCALE,
-                          height: EMBED_INVERSE_SCALE,
-                          transform: `scale(${EMBED_SCALE})`,
-                        }}
-                      />
-                    </span>
-                  )}
-                  {embedInfo.type === 'video' && (
-                    <video
-                      src={embedInfo.url}
-                      controls
-                      preload='metadata'
-                      className='aspect-video w-full'
-                    >
-                      <track kind='captions' src='' default />
-                    </video>
-                  )}
-                  {embedInfo.type === 'audio' && (
-                    <audio src={embedInfo.url} controls preload='metadata' className='w-full'>
-                      <track kind='captions' src='' default />
-                    </audio>
-                  )}
-                </span>
+                <iframe
+                  src={embedInfo.url}
+                  title='Media'
+                  allow='accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share'
+                  allowFullScreen
+                  loading='lazy'
+                  className='origin-top-left'
+                  style={{
+                    width: EMBED_INVERSE_SCALE,
+                    height: EMBED_INVERSE_SCALE,
+                    transform: `scale(${EMBED_SCALE})`,
+                  }}
+                />
               </span>
-            )
-          }
-          return (
-            <a
-              href={href}
-              target='_blank'
-              rel='noopener noreferrer'
-              className='break-all text-[var(--brand-secondary)] underline-offset-2 hover-hover:underline'
-            >
-              {children}
-            </a>
-          )
-        },
-        strong: ({ children }: any) => (
-          <strong className='break-words font-semibold text-[var(--text-primary)]'>
-            {children}
-          </strong>
-        ),
-        em: ({ children }: any) => (
-          <em className='break-words text-[var(--text-tertiary)]'>{children}</em>
-        ),
-        blockquote: ({ children }: any) => (
-          <blockquote className='my-4 break-words border-[var(--border-1)] border-l-4 py-1 pl-4 text-[var(--text-tertiary)] italic'>
-            {children}
-          </blockquote>
-        ),
-        table: ({ children }: any) => (
-          <div className='my-2 max-w-full overflow-x-auto'>
-            <table className='w-full border-collapse text-xs'>{children}</table>
-          </div>
-        ),
-        thead: ({ children }: any) => (
-          <thead className='border-[var(--border)] border-b'>{children}</thead>
-        ),
-        tbody: ({ children }: any) => <tbody>{children}</tbody>,
-        tr: ({ children }: any) => (
-          <tr className='border-[var(--border)] border-b last:border-b-0'>{children}</tr>
-        ),
-        th: ({ children }: any) => (
-          <th className='px-2 py-1 text-left font-semibold text-[var(--text-primary)]'>
-            {children}
-          </th>
-        ),
-        td: ({ children }: any) => (
-          <td className='px-2 py-1 text-[var(--text-secondary)]'>{children}</td>
-        ),
-      }}
-    >
+            )}
+            {embedInfo.type === 'video' && (
+              <video
+                src={embedInfo.url}
+                controls
+                preload='metadata'
+                className='aspect-video w-full'
+              >
+                <track kind='captions' src='' default />
+              </video>
+            )}
+            {embedInfo.type === 'audio' && (
+              <audio src={embedInfo.url} controls preload='metadata' className='w-full'>
+                <track kind='captions' src='' default />
+              </audio>
+            )}
+          </span>
+        </span>
+      )
+    }
+    return (
+      <a
+        href={href}
+        target='_blank'
+        rel='noopener noreferrer'
+        className='break-all text-[var(--brand-secondary)] underline-offset-2 hover-hover:underline'
+      >
+        {children}
+      </a>
+    )
+  },
+  strong: ({ children }: { children?: React.ReactNode }) => (
+    <strong className='break-words font-semibold text-[var(--text-primary)]'>{children}</strong>
+  ),
+  em: ({ children }: { children?: React.ReactNode }) => (
+    <em className='break-words text-[var(--text-tertiary)]'>{children}</em>
+  ),
+  blockquote: ({ children }: { children?: React.ReactNode }) => (
+    <blockquote className='my-4 break-words border-[var(--border-1)] border-l-4 py-1 pl-4 text-[var(--text-tertiary)] italic'>
+      {children}
+    </blockquote>
+  ),
+  table: ({ children }: { children?: React.ReactNode }) => (
+    <div className='my-2 max-w-full overflow-x-auto'>
+      <table className='w-full border-collapse text-xs'>{children}</table>
+    </div>
+  ),
+  thead: ({ children }: { children?: React.ReactNode }) => (
+    <thead className='border-[var(--border)] border-b'>{children}</thead>
+  ),
+  tbody: ({ children }: { children?: React.ReactNode }) => <tbody>{children}</tbody>,
+  tr: ({ children }: { children?: React.ReactNode }) => (
+    <tr className='border-[var(--border)] border-b last:border-b-0'>{children}</tr>
+  ),
+  th: ({ children }: { children?: React.ReactNode }) => (
+    <th className='px-2 py-1 text-left font-semibold text-[var(--text-primary)]'>{children}</th>
+  ),
+  td: ({ children }: { children?: React.ReactNode }) => (
+    <td className='px-2 py-1 text-[var(--text-secondary)]'>{children}</td>
+  ),
+}
+
+const NoteMarkdown = memo(function NoteMarkdown({ content }: { content: string }) {
+  return (
+    <Streamdown mode='static' remarkPlugins={NOTE_REMARK_PLUGINS} components={NOTE_COMPONENTS}>
       {content}
-    </ReactMarkdown>
+    </Streamdown>
   )
 })
 
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tag-dropdown/tag-dropdown.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tag-dropdown/tag-dropdown.tsx
index 620d38c2e83..df16b87b5bf 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tag-dropdown/tag-dropdown.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tag-dropdown/tag-dropdown.tsx
@@ -14,12 +14,11 @@ import {
 } from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import {
-  getEffectiveBlockOutputPaths,
   getEffectiveBlockOutputType,
   getOutputPathsFromSchema,
 } from '@/lib/workflows/blocks/block-outputs'
+import { getBlockReferenceTags } from '@/lib/workflows/blocks/block-reference-tags'
 import { hasTriggerCapability } from '@/lib/workflows/triggers/trigger-utils'
-import { TRIGGER_TYPES } from '@/lib/workflows/triggers/triggers'
 import { KeyboardNavigationHandler } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/tag-dropdown/components/keyboard-navigation-handler'
 import type {
   BlockTagGroup,
@@ -177,17 +176,6 @@ const ensureRootTag = (tags: string[], rootTag: string): string[] => {
   return [rootTag, ...tags]
 }
 
-/**
- * Gets a subblock value from the store.
- *
- * @param blockId - The block identifier
- * @param property - The property name to retrieve
- * @returns The value from the subblock store
- */
-const getSubBlockValue = (blockId: string, property: string): any => {
-  return useSubBlockStore.getState().getValue(blockId, property)
-}
-
 /**
  * Gets the output type for a specific path in a block's outputs.
  *
@@ -1055,53 +1043,19 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
         return { tags: [], variableInfoMap: emptyVariableInfoMap, blockTagGroups: [] }
       }
 
-      const blockName = sourceBlock.name || sourceBlock.type
-      const normalizedBlockName = normalizeName(blockName)
-
       const mergedSubBlocks = getMergedSubBlocks(activeSourceBlockId)
-      let blockTags: string[]
-
-      if (sourceBlock.type === 'variables') {
-        const variablesValue = getSubBlockValue(activeSourceBlockId, 'variables')
-
-        if (variablesValue && Array.isArray(variablesValue) && variablesValue.length > 0) {
-          const validAssignments = variablesValue.filter((assignment: { variableName?: string }) =>
-            assignment?.variableName?.trim()
-          )
-          blockTags = validAssignments.map(
-            (assignment: { variableName: string }) =>
-              `${normalizedBlockName}.${assignment.variableName.trim()}`
-          )
-        } else {
-          blockTags = [normalizedBlockName]
-        }
-      } else {
-        const sourceBlockConfig = getBlock(sourceBlock.type)
-        const isTriggerCapable = sourceBlockConfig ? hasTriggerCapability(sourceBlockConfig) : false
-        const effectiveTriggerMode = Boolean(sourceBlock.triggerMode && isTriggerCapable)
-        const outputPaths = getEffectiveBlockOutputPaths(sourceBlock.type, mergedSubBlocks, {
-          triggerMode: effectiveTriggerMode,
-          preferToolOutputs: !effectiveTriggerMode,
-        })
-        const allTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
-
-        if (sourceBlock.type === 'human_in_the_loop' && activeSourceBlockId === blockId) {
-          blockTags = allTags.filter(
-            (tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint')
-          )
-        } else if (allTags.length === 0) {
-          blockTags = [normalizedBlockName]
-        } else {
-          blockTags = allTags
-        }
-      }
-
-      blockTags = ensureRootTag(blockTags, normalizedBlockName)
-      const shouldShowRootTag =
-        sourceBlock.type === TRIGGER_TYPES.GENERIC_WEBHOOK || sourceBlock.type === 'start_trigger'
-      if (!shouldShowRootTag) {
-        blockTags = blockTags.filter((tag) => tag !== normalizedBlockName)
-      }
+      const blockName = sourceBlock.name || sourceBlock.type
+      const blockTags = getBlockReferenceTags({
+        block: {
+          id: activeSourceBlockId,
+          type: sourceBlock.type,
+          name: sourceBlock.name,
+          triggerMode: sourceBlock.triggerMode,
+          subBlocks: mergedSubBlocks,
+        },
+        currentBlockId: blockId,
+        subBlocks: mergedSubBlocks,
+      })
 
       const blockTagGroups: BlockTagGroup[] = [
         {
@@ -1331,57 +1285,19 @@ export const TagDropdown: React.FC<TagDropdownProps> = ({
         continue
       }
 
-      const blockName = accessibleBlock.name || accessibleBlock.type
-      const normalizedBlockName = normalizeName(blockName)
-
       const mergedSubBlocks = getMergedSubBlocks(accessibleBlockId)
-
-      let blockTags: string[]
-
-      if (accessibleBlock.type === 'variables') {
-        const variablesValue = getSubBlockValue(accessibleBlockId, 'variables')
-
-        if (variablesValue && Array.isArray(variablesValue) && variablesValue.length > 0) {
-          const validAssignments = variablesValue.filter((assignment: { variableName?: string }) =>
-            assignment?.variableName?.trim()
-          )
-          blockTags = validAssignments.map(
-            (assignment: { variableName: string }) =>
-              `${normalizedBlockName}.${assignment.variableName.trim()}`
-          )
-        } else {
-          blockTags = [normalizedBlockName]
-        }
-      } else {
-        const accessibleBlockConfig = getBlock(accessibleBlock.type)
-        const isTriggerCapable = accessibleBlockConfig
-          ? hasTriggerCapability(accessibleBlockConfig)
-          : false
-        const effectiveTriggerMode = Boolean(accessibleBlock.triggerMode && isTriggerCapable)
-        const outputPaths = getEffectiveBlockOutputPaths(accessibleBlock.type, mergedSubBlocks, {
-          triggerMode: effectiveTriggerMode,
-          preferToolOutputs: !effectiveTriggerMode,
-        })
-        const allTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
-
-        if (accessibleBlock.type === 'human_in_the_loop' && accessibleBlockId === blockId) {
-          blockTags = allTags.filter(
-            (tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint')
-          )
-        } else if (allTags.length === 0) {
-          blockTags = [normalizedBlockName]
-        } else {
-          blockTags = allTags
-        }
-      }
-
-      blockTags = ensureRootTag(blockTags, normalizedBlockName)
-      const shouldShowRootTag =
-        accessibleBlock.type === TRIGGER_TYPES.GENERIC_WEBHOOK ||
-        accessibleBlock.type === 'start_trigger'
-      if (!shouldShowRootTag) {
-        blockTags = blockTags.filter((tag) => tag !== normalizedBlockName)
-      }
+      const blockName = accessibleBlock.name || accessibleBlock.type
+      const blockTags = getBlockReferenceTags({
+        block: {
+          id: accessibleBlockId,
+          type: accessibleBlock.type,
+          name: accessibleBlock.name,
+          triggerMode: accessibleBlock.triggerMode,
+          subBlocks: mergedSubBlocks,
+        },
+        currentBlockId: blockId,
+        subBlocks: mergedSubBlocks,
+      })
 
       blockTagGroups.push({
         blockName,
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx
index da51910789b..5051fb83178 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx
@@ -224,7 +224,7 @@ export const Panel = memo(function Panel({ workspaceId: propWorkspaceId }: Panel
   const [copilotChatId, setCopilotChatId] = useState<string | undefined>(undefined)
   const [copilotChatTitle, setCopilotChatTitle] = useState<string | null>(null)
   const [copilotChatList, setCopilotChatList] = useState<
-    { id: string; title: string | null; updatedAt: string; conversationId: string | null }[]
+    { id: string; title: string | null; updatedAt: string; activeStreamId: string | null }[]
   >([])
   const [isCopilotHistoryOpen, setIsCopilotHistoryOpen] = useState(false)
 
@@ -244,7 +244,7 @@ export const Panel = memo(function Panel({ workspaceId: propWorkspaceId }: Panel
           id: string
           title: string | null
           updatedAt: string
-          conversationId: string | null
+          activeStreamId: string | null
         }>
         setCopilotChatList(filtered)
 
@@ -813,7 +813,7 @@ export const Panel = memo(function Panel({ workspaceId: propWorkspaceId }: Panel
                                   >
                                     <ConversationListItem
                                       title={chat.title || 'New Chat'}
-                                      isActive={Boolean(chat.conversationId)}
+                                      isActive={Boolean(chat.activeStreamId)}
                                       titleClassName='text-[13px]'
                                       actions={
                                         <div
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx
index 6df9c6a5d72..cdbb138b568 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-block/workflow-block.tsx
@@ -10,7 +10,8 @@ import { getBaseUrl } from '@/lib/core/utils/urls'
 import { createMcpToolId } from '@/lib/mcp/shared'
 import { getProviderIdFromServiceId } from '@/lib/oauth'
 import type { FilterRule, SortRule } from '@/lib/table/types'
-import { BLOCK_DIMENSIONS, HANDLE_POSITIONS } from '@/lib/workflows/blocks/block-dimensions'
+import { HANDLE_POSITIONS } from '@/lib/workflows/blocks/block-dimensions'
+import { calculateWorkflowBlockDimensions } from '@/lib/workflows/blocks/deterministic-dimensions'
 import { getConditionRows, getRouterRows } from '@/lib/workflows/dynamic-handle-topology'
 import {
   buildCanonicalIndex,
@@ -1145,33 +1146,14 @@ export const WorkflowBlock = memo(function WorkflowBlock({
   useBlockDimensions({
     blockId: id,
     calculateDimensions: () => {
-      const shouldShowDefaultHandles =
-        config.category !== 'triggers' && type !== 'starter' && !displayTriggerMode
-      const hasContentBelowHeader = subBlockRows.length > 0 || shouldShowDefaultHandles
-
-      const defaultHandlesRow = shouldShowDefaultHandles ? 1 : 0
-
-      let rowsCount = 0
-      if (type === 'condition') {
-        rowsCount = conditionRows.length + defaultHandlesRow
-      } else if (type === 'router_v2') {
-        // +1 for context row, plus route rows
-        rowsCount = 1 + routerRows.length + defaultHandlesRow
-      } else {
-        const subblockRowCount = subBlockRows.reduce((acc, row) => acc + row.length, 0)
-        rowsCount = subblockRowCount + defaultHandlesRow
-      }
-
-      const contentHeight = hasContentBelowHeader
-        ? BLOCK_DIMENSIONS.WORKFLOW_CONTENT_PADDING +
-          rowsCount * BLOCK_DIMENSIONS.WORKFLOW_ROW_HEIGHT
-        : 0
-      const calculatedHeight = Math.max(
-        BLOCK_DIMENSIONS.HEADER_HEIGHT + contentHeight,
-        BLOCK_DIMENSIONS.MIN_HEIGHT
-      )
-
-      return { width: BLOCK_DIMENSIONS.FIXED_WIDTH, height: calculatedHeight }
+      return calculateWorkflowBlockDimensions({
+        blockType: type,
+        category: config.category,
+        displayTriggerMode,
+        visibleSubBlockCount: subBlockRows.reduce((acc, row) => acc + row.length, 0),
+        conditionRowCount: conditionRows.length,
+        routerRowCount: routerRows.length,
+      })
     },
     dependencies: [
       type,
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts
index fe22f6164bd..f323d4c3871 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts
@@ -568,7 +568,9 @@ export interface WorkflowExecutionOptions {
   onStream?: (se: StreamingExecution) => Promise<void>
   executionId?: string
   onBlockComplete?: (blockId: string, output: any) => Promise<void>
-  overrideTriggerType?: 'chat' | 'manual' | 'api' | 'copilot'
+  overrideTriggerType?: 'chat' | 'manual' | 'api' | 'copilot' | 'webhook' | 'schedule'
+  triggerBlockId?: string
+  useDraftState?: boolean
   stopAfterBlockId?: string
   abortSignal?: AbortSignal
   /** For run_from_block / run_block: start from a specific block using cached state */
@@ -625,8 +627,9 @@ export async function executeWorkflowWithFullLogging(
     input: options.workflowInput,
     stream: true,
     triggerType: options.overrideTriggerType || 'manual',
-    useDraftState: true,
+    useDraftState: options.useDraftState ?? true,
     isClientSession: true,
+    ...(options.triggerBlockId ? { triggerBlockId: options.triggerBlockId } : {}),
     ...(options.stopAfterBlockId ? { stopAfterBlockId: options.stopAfterBlockId } : {}),
     ...(options.runFromBlock
       ? {
diff --git a/apps/sim/background/workspace-notification-delivery.ts b/apps/sim/background/workspace-notification-delivery.ts
index db61f05cc63..7bdde512299 100644
--- a/apps/sim/background/workspace-notification-delivery.ts
+++ b/apps/sim/background/workspace-notification-delivery.ts
@@ -16,15 +16,12 @@ import {
 import { checkUsageStatus } from '@/lib/billing/calculations/usage-monitor'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
 import { dollarsToCredits } from '@/lib/billing/credits/conversion'
-import { createBullMQJobData, isBullMQEnabled } from '@/lib/core/bullmq'
-import { acquireLock } from '@/lib/core/config/redis'
 import { RateLimiter } from '@/lib/core/rate-limiter'
 import { decryptSecret } from '@/lib/core/security/encryption'
 import { secureFetchWithValidation } from '@/lib/core/security/input-validation.server'
 import { formatDuration } from '@/lib/core/utils/formatting'
 import { getBaseUrl } from '@/lib/core/utils/urls'
 import { generateId } from '@/lib/core/utils/uuid'
-import { enqueueWorkspaceDispatch } from '@/lib/core/workspace-dispatch'
 import type { TraceSpan, WorkflowExecutionLog } from '@/lib/logs/types'
 import { sendEmail } from '@/lib/messaging/email/mailer'
 import type { AlertConfig } from '@/lib/notifications/alert-rules'
@@ -35,8 +32,6 @@ const logger = createLogger('WorkspaceNotificationDelivery')
 
 const MAX_ATTEMPTS = 5
 const RETRY_DELAYS = [5 * 1000, 15 * 1000, 60 * 1000, 3 * 60 * 1000, 10 * 60 * 1000]
-const NOTIFICATION_DISPATCH_LOCK_TTL_SECONDS = 3
-
 function getRetryDelayWithJitter(baseDelay: number): number {
   const jitter = Math.random() * 0.1 * baseDelay
   return Math.floor(baseDelay + jitter)
@@ -534,42 +529,14 @@ async function buildRetryLog(params: NotificationDeliveryParams): Promise<Workfl
 }
 
 export async function enqueueNotificationDeliveryDispatch(
-  params: NotificationDeliveryParams
+  _params: NotificationDeliveryParams
 ): Promise<boolean> {
-  if (!isBullMQEnabled()) {
-    return false
-  }
-
-  const lockAcquired = await acquireLock(
-    `workspace-notification-dispatch:${params.deliveryId}`,
-    params.deliveryId,
-    NOTIFICATION_DISPATCH_LOCK_TTL_SECONDS
-  )
-  if (!lockAcquired) {
-    return false
-  }
-
-  await enqueueWorkspaceDispatch({
-    workspaceId: params.workspaceId,
-    lane: 'lightweight',
-    queueName: 'workspace-notification-delivery',
-    bullmqJobName: 'workspace-notification-delivery',
-    bullmqPayload: createBullMQJobData(params),
-    metadata: {
-      workflowId: params.log.workflowId ?? undefined,
-    },
-  })
-
-  return true
+  return false
 }
 
 const STUCK_IN_PROGRESS_THRESHOLD_MS = 5 * 60 * 1000
 
 export async function sweepPendingNotificationDeliveries(limit = 50): Promise<number> {
-  if (!isBullMQEnabled()) {
-    return 0
-  }
-
   const stuckThreshold = new Date(Date.now() - STUCK_IN_PROGRESS_THRESHOLD_MS)
 
   await db
diff --git a/apps/sim/executor/handlers/mothership/mothership-handler.test.ts b/apps/sim/executor/handlers/mothership/mothership-handler.test.ts
new file mode 100644
index 00000000000..524c1e3ad65
--- /dev/null
+++ b/apps/sim/executor/handlers/mothership/mothership-handler.test.ts
@@ -0,0 +1,219 @@
+import '@sim/testing/mocks/executor'
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { BlockType } from '@/executor/constants'
+import { MothershipBlockHandler } from '@/executor/handlers/mothership/mothership-handler'
+import type { ExecutionContext } from '@/executor/types'
+import type { SerializedBlock } from '@/serializer/types'
+
+const {
+  mockBuildAuthHeaders,
+  mockBuildAPIUrl,
+  mockExtractAPIErrorMessage,
+  mockGenerateId,
+  mockIsExecutionCancelled,
+  mockIsRedisCancellationEnabled,
+} = vi.hoisted(() => ({
+  mockBuildAuthHeaders: vi.fn(),
+  mockBuildAPIUrl: vi.fn(),
+  mockExtractAPIErrorMessage: vi.fn(),
+  mockGenerateId: vi.fn(),
+  mockIsExecutionCancelled: vi.fn(),
+  mockIsRedisCancellationEnabled: vi.fn(),
+}))
+
+vi.mock('@/executor/utils/http', () => ({
+  buildAuthHeaders: mockBuildAuthHeaders,
+  buildAPIUrl: mockBuildAPIUrl,
+  extractAPIErrorMessage: mockExtractAPIErrorMessage,
+}))
+
+vi.mock('@/lib/core/utils/uuid', () => ({
+  generateId: mockGenerateId,
+}))
+
+vi.mock('@/lib/execution/cancellation', () => ({
+  isExecutionCancelled: mockIsExecutionCancelled,
+  isRedisCancellationEnabled: mockIsRedisCancellationEnabled,
+}))
+
+vi.mock('@sim/logger', () => {
+  const createMockLogger = (): Record<string, any> => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+    withMetadata: vi.fn(() => createMockLogger()),
+  })
+
+  return {
+    createLogger: vi.fn(() => createMockLogger()),
+  }
+})
+
+function createAbortError(): Error {
+  const error = new Error('The operation was aborted')
+  error.name = 'AbortError'
+  return error
+}
+
+function createAbortableFetchPromise(signal?: AbortSignal): Promise<Response> {
+  return new Promise((_resolve, reject) => {
+    if (signal?.aborted) {
+      reject(createAbortError())
+      return
+    }
+
+    signal?.addEventListener(
+      'abort',
+      () => {
+        reject(createAbortError())
+      },
+      { once: true }
+    )
+  })
+}
+
+describe('MothershipBlockHandler', () => {
+  let handler: MothershipBlockHandler
+  let block: SerializedBlock
+  let context: ExecutionContext
+  let fetchMock: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    handler = new MothershipBlockHandler()
+    fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+
+    mockBuildAuthHeaders.mockResolvedValue({ Authorization: 'Bearer internal' })
+    mockBuildAPIUrl.mockReturnValue(new URL('/api/mothership/execute', 'http://localhost:3000'))
+    mockExtractAPIErrorMessage.mockResolvedValue('boom')
+    mockGenerateId.mockReset()
+    mockIsExecutionCancelled.mockReset()
+    mockIsRedisCancellationEnabled.mockReset()
+    mockIsRedisCancellationEnabled.mockReturnValue(false)
+
+    block = {
+      id: 'mothership-block-1',
+      metadata: { id: BlockType.MOTHERSHIP, name: 'Mothership' },
+      position: { x: 0, y: 0 },
+      config: { tool: BlockType.MOTHERSHIP, params: {} },
+      inputs: { prompt: 'string' },
+      outputs: {},
+      enabled: true,
+    } as SerializedBlock
+
+    context = {
+      workflowId: 'workflow-1',
+      executionId: 'execution-1',
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      blockStates: new Map(),
+      blockLogs: [],
+      metadata: { duration: 0 },
+      environmentVariables: {},
+      decisions: { router: new Map(), condition: new Map() },
+      loopExecutions: new Map(),
+      completedLoops: new Set(),
+      executedBlocks: new Set(),
+      activeExecutionPath: new Set(),
+    } as ExecutionContext
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.clearAllMocks()
+    vi.unstubAllGlobals()
+  })
+
+  it('forwards workflow and execution metadata with generated UUID ids', async () => {
+    mockGenerateId.mockReturnValueOnce('chat-uuid')
+    mockGenerateId.mockReturnValueOnce('message-uuid')
+    mockGenerateId.mockReturnValueOnce('request-uuid')
+
+    fetchMock.mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          content: 'done',
+          model: 'mothership',
+          tokens: { total: 5 },
+          toolCalls: [],
+        }),
+        {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        }
+      )
+    )
+
+    const result = await handler.execute(context, block, { prompt: 'Hello from workflow' })
+
+    expect(result).toEqual({
+      content: 'done',
+      model: 'mothership',
+      tokens: { total: 5 },
+      toolCalls: { list: [], count: 0 },
+      cost: undefined,
+    })
+
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    const [url, options] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(url).toBe('http://localhost:3000/api/mothership/execute')
+    expect(options.method).toBe('POST')
+    expect(options.signal).toBeInstanceOf(AbortSignal)
+
+    const body = JSON.parse(String(options.body))
+    expect(body).toEqual({
+      messages: [{ role: 'user', content: 'Hello from workflow' }],
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      chatId: 'chat-uuid',
+      messageId: 'message-uuid',
+      requestId: 'request-uuid',
+      workflowId: 'workflow-1',
+      executionId: 'execution-1',
+    })
+  })
+
+  it('propagates local aborts to the mothership request', async () => {
+    const abortController = new AbortController()
+    context.abortSignal = abortController.signal
+
+    mockGenerateId.mockReturnValueOnce('chat-uuid')
+    mockGenerateId.mockReturnValueOnce('message-uuid')
+    mockGenerateId.mockReturnValueOnce('request-uuid')
+
+    fetchMock.mockImplementation((_url: string, options?: RequestInit) =>
+      createAbortableFetchPromise(options?.signal as AbortSignal | undefined)
+    )
+
+    const executionPromise = handler.execute(context, block, { prompt: 'Abort me' })
+    const abortedExecution = executionPromise.catch((error) => error)
+
+    abortController.abort()
+
+    await expect(abortedExecution).resolves.toMatchObject({ name: 'AbortError' })
+  })
+
+  it('propagates durable workflow cancellation to the mothership request', async () => {
+    vi.useFakeTimers()
+
+    mockGenerateId.mockReturnValueOnce('chat-uuid')
+    mockGenerateId.mockReturnValueOnce('message-uuid')
+    mockGenerateId.mockReturnValueOnce('request-uuid')
+    mockIsRedisCancellationEnabled.mockReturnValue(true)
+    mockIsExecutionCancelled.mockResolvedValueOnce(false).mockResolvedValueOnce(true)
+
+    fetchMock.mockImplementation((_url: string, options?: RequestInit) =>
+      createAbortableFetchPromise(options?.signal as AbortSignal | undefined)
+    )
+
+    const executionPromise = handler.execute(context, block, { prompt: 'Cancel me durably' })
+    const abortedExecution = executionPromise.catch((error) => error)
+
+    await vi.advanceTimersByTimeAsync(1000)
+
+    await expect(abortedExecution).resolves.toMatchObject({ name: 'AbortError' })
+    expect(mockIsExecutionCancelled).toHaveBeenCalledWith('execution-1')
+  })
+})
diff --git a/apps/sim/executor/handlers/mothership/mothership-handler.ts b/apps/sim/executor/handlers/mothership/mothership-handler.ts
index 0b40a17fdc4..8f98ce4404e 100644
--- a/apps/sim/executor/handlers/mothership/mothership-handler.ts
+++ b/apps/sim/executor/handlers/mothership/mothership-handler.ts
@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { generateId } from '@/lib/core/utils/uuid'
+import { isExecutionCancelled, isRedisCancellationEnabled } from '@/lib/execution/cancellation'
 import type { BlockOutput } from '@/blocks/types'
 import { BlockType } from '@/executor/constants'
 import type { BlockHandler, ExecutionContext } from '@/executor/types'
@@ -7,6 +8,7 @@ import { buildAPIUrl, buildAuthHeaders, extractAPIErrorMessage } from '@/executo
 import type { SerializedBlock } from '@/serializer/types'
 
 const logger = createLogger('MothershipBlockHandler')
+const CANCELLATION_CHECK_INTERVAL_MS = 500
 
 /**
  * Handler for Mothership blocks that proxy requests to the Mothership AI agent.
@@ -31,6 +33,8 @@ export class MothershipBlockHandler implements BlockHandler {
     }
     const messages = [{ role: 'user' as const, content: prompt }]
     const chatId = generateId()
+    const messageId = generateId()
+    const requestId = generateId()
 
     const url = buildAPIUrl('/api/mothership/execute')
     const headers = await buildAuthHeaders(ctx.userId)
@@ -40,17 +44,76 @@ export class MothershipBlockHandler implements BlockHandler {
       workspaceId: ctx.workspaceId || '',
       userId: ctx.userId || '',
       chatId,
+      messageId,
+      requestId,
+      ...(ctx.workflowId ? { workflowId: ctx.workflowId } : {}),
+      ...(ctx.executionId ? { executionId: ctx.executionId } : {}),
     }
 
     logger.info('Executing Mothership block', {
       blockId: block.id,
+      messageId,
+      requestId,
+      workflowId: ctx.workflowId,
+      executionId: ctx.executionId,
     })
 
-    const response = await fetch(url.toString(), {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-    })
+    const abortController = new AbortController()
+    const onAbort = () => {
+      if (!abortController.signal.aborted) {
+        abortController.abort(ctx.abortSignal?.reason ?? 'workflow_abort')
+      }
+    }
+
+    if (ctx.abortSignal?.aborted) {
+      onAbort()
+    } else {
+      ctx.abortSignal?.addEventListener('abort', onAbort, { once: true })
+    }
+
+    const executionId = ctx.executionId
+    const useRedisCancellation = isRedisCancellationEnabled() && !!executionId
+    let pollInFlight = false
+    const cancellationPoller =
+      useRedisCancellation && executionId
+        ? setInterval(() => {
+            if (pollInFlight || abortController.signal.aborted) {
+              return
+            }
+            pollInFlight = true
+            void isExecutionCancelled(executionId)
+              .then((cancelled) => {
+                if (cancelled && !abortController.signal.aborted) {
+                  abortController.abort('workflow_execution_cancelled')
+                }
+              })
+              .catch((error) => {
+                logger.warn('Failed to poll workflow cancellation for Mothership block', {
+                  blockId: block.id,
+                  executionId,
+                  error: error instanceof Error ? error.message : String(error),
+                })
+              })
+              .finally(() => {
+                pollInFlight = false
+              })
+          }, CANCELLATION_CHECK_INTERVAL_MS)
+        : undefined
+
+    let response: Response
+    try {
+      response = await fetch(url.toString(), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal: abortController.signal,
+      })
+    } finally {
+      if (cancellationPoller) {
+        clearInterval(cancellationPoller)
+      }
+      ctx.abortSignal?.removeEventListener('abort', onAbort)
+    }
 
     if (!response.ok) {
       const errorMsg = await extractAPIErrorMessage(response)
diff --git a/apps/sim/executor/types.ts b/apps/sim/executor/types.ts
index d02eecc0122..00caff1d9ef 100644
--- a/apps/sim/executor/types.ts
+++ b/apps/sim/executor/types.ts
@@ -177,6 +177,7 @@ export interface ExecutionContext {
   userId?: string
   isDeployedContext?: boolean
   enforceCredentialAccess?: boolean
+  copilotToolExecution?: boolean
 
   permissionConfig?: PermissionGroupConfig | null
   permissionConfigLoaded?: boolean
diff --git a/apps/sim/executor/utils/start-block.ts b/apps/sim/executor/utils/start-block.ts
index 5ac0936e1b1..de674f0445a 100644
--- a/apps/sim/executor/utils/start-block.ts
+++ b/apps/sim/executor/utils/start-block.ts
@@ -10,7 +10,7 @@ import type { NormalizedBlockOutput, UserFile } from '@/executor/types'
 import type { SerializedBlock } from '@/serializer/types'
 import { safeAssign } from '@/tools/safe-assign'
 
-type ExecutionKind = 'chat' | 'manual' | 'api'
+type ExecutionKind = 'chat' | 'manual' | 'api' | 'external'
 
 export interface ExecutorStartResolution {
   blockId: string
diff --git a/apps/sim/hooks/queries/mothership-admin.ts b/apps/sim/hooks/queries/mothership-admin.ts
new file mode 100644
index 00000000000..592daea4d86
--- /dev/null
+++ b/apps/sim/hooks/queries/mothership-admin.ts
@@ -0,0 +1,131 @@
+import { keepPreviousData, useMutation, useQuery } from '@tanstack/react-query'
+
+export type MothershipEnv = 'dev' | 'staging' | 'prod'
+
+const BASE = '/api/admin/mothership'
+
+async function mothershipPost(
+  endpoint: string,
+  environment: MothershipEnv,
+  body?: Record<string, unknown>
+) {
+  const res = await fetch(`${BASE}?env=${environment}&endpoint=${endpoint}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }))
+    throw new Error(err.message || err.error || `Request failed (${res.status})`)
+  }
+  return res.json()
+}
+
+async function mothershipGet(
+  endpoint: string,
+  environment: MothershipEnv,
+  params?: Record<string, string>
+) {
+  const qs = new URLSearchParams({ env: environment, endpoint, ...params })
+  const res = await fetch(`${BASE}?${qs.toString()}`, { method: 'GET' })
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: res.statusText }))
+    throw new Error(err.message || err.error || `Request failed (${res.status})`)
+  }
+  return res.json()
+}
+
+export const mothershipKeys = {
+  all: ['mothership-admin'] as const,
+  requests: (env: MothershipEnv, start: string, end: string, userId?: string) =>
+    [...mothershipKeys.all, 'requests', env, start, end, userId] as const,
+  userBreakdown: (env: MothershipEnv, start: string, end: string) =>
+    [...mothershipKeys.all, 'user-breakdown', env, start, end] as const,
+  licenses: (env: MothershipEnv) => [...mothershipKeys.all, 'licenses', env] as const,
+  licenseDetails: (env: MothershipEnv, id?: string, name?: string) =>
+    [...mothershipKeys.all, 'license-details', env, id, name] as const,
+  enterpriseStats: (env: MothershipEnv, customerType: string, start: string, end: string) =>
+    [...mothershipKeys.all, 'enterprise-stats', env, customerType, start, end] as const,
+  trace: (env: MothershipEnv, requestId: string) =>
+    [...mothershipKeys.all, 'trace', env, requestId] as const,
+}
+
+export function useMothershipRequests(
+  environment: MothershipEnv,
+  start: string,
+  end: string,
+  userId?: string
+) {
+  return useQuery({
+    queryKey: mothershipKeys.requests(environment, start, end, userId),
+    queryFn: () =>
+      mothershipPost('requests', environment, {
+        start,
+        end,
+        ...(userId ? { userId } : {}),
+      }),
+    enabled: !!start && !!end,
+    placeholderData: keepPreviousData,
+  })
+}
+
+export function useMothershipUserBreakdown(environment: MothershipEnv, start: string, end: string) {
+  return useQuery({
+    queryKey: mothershipKeys.userBreakdown(environment, start, end),
+    queryFn: () => mothershipPost('user-breakdown', environment, { start, end }),
+    enabled: !!start && !!end,
+    placeholderData: keepPreviousData,
+  })
+}
+
+export function useMothershipLicenses(environment: MothershipEnv) {
+  return useQuery({
+    queryKey: mothershipKeys.licenses(environment),
+    queryFn: () => mothershipGet('licenses', environment),
+  })
+}
+
+export function useMothershipLicenseDetails(
+  environment: MothershipEnv,
+  id?: string,
+  name?: string
+) {
+  return useQuery({
+    queryKey: mothershipKeys.licenseDetails(environment, id, name),
+    queryFn: () =>
+      mothershipPost('licenses/details', environment, {
+        ...(id ? { id } : {}),
+        ...(name ? { name } : {}),
+      }),
+    enabled: !!(id || name),
+  })
+}
+
+export function useGenerateLicense(environment: MothershipEnv) {
+  return useMutation({
+    mutationFn: (params: { name: string; expirationDate?: string }) =>
+      mothershipPost('licenses/generate', environment, params),
+  })
+}
+
+export function useMothershipEnterpriseStats(
+  environment: MothershipEnv,
+  customerType: string,
+  start: string,
+  end: string
+) {
+  return useQuery({
+    queryKey: mothershipKeys.enterpriseStats(environment, customerType, start, end),
+    queryFn: () => mothershipPost('enterprise-stats', environment, { customerType, start, end }),
+    enabled: !!customerType && !!start && !!end,
+    placeholderData: keepPreviousData,
+  })
+}
+
+export function useMothershipTrace(environment: MothershipEnv, requestId: string) {
+  return useQuery({
+    queryKey: mothershipKeys.trace(environment, requestId),
+    queryFn: () => mothershipGet('traces', environment, { requestId }),
+    enabled: !!requestId,
+  })
+}
diff --git a/apps/sim/hooks/queries/tasks.test.ts b/apps/sim/hooks/queries/tasks.test.ts
new file mode 100644
index 00000000000..ccfb3bf91c2
--- /dev/null
+++ b/apps/sim/hooks/queries/tasks.test.ts
@@ -0,0 +1,174 @@
+/**
+ * @vitest-environment node
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { MothershipResource } from '@/lib/copilot/resources/types'
+
+const { queryClient } = vi.hoisted(() => ({
+  queryClient: {
+    cancelQueries: vi.fn().mockResolvedValue(undefined),
+    invalidateQueries: vi.fn().mockResolvedValue(undefined),
+    getQueryData: vi.fn(),
+    setQueryData: vi.fn(),
+  },
+}))
+
+vi.mock('@tanstack/react-query', () => ({
+  keepPreviousData: {},
+  useQuery: vi.fn(),
+  useQueryClient: vi.fn(() => queryClient),
+  useMutation: vi.fn((options) => options),
+}))
+
+import { fetchChatHistory, fetchTasks, useAddChatResource } from '@/hooks/queries/tasks'
+
+function jsonResponse(body: unknown, init?: ResponseInit): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    ...init,
+  })
+}
+
+describe('tasks query boundary parsing', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.stubGlobal('fetch', vi.fn())
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('parses valid task metadata responses', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      jsonResponse({
+        success: true,
+        data: [
+          {
+            id: 'chat-1',
+            title: 'Launch plan',
+            updatedAt: '2026-04-11T10:00:00.000Z',
+            activeStreamId: 'stream-1',
+            lastSeenAt: null,
+          },
+        ],
+      })
+    )
+
+    const tasks = await fetchTasks('ws-1')
+
+    expect(tasks).toHaveLength(1)
+    expect(tasks[0]).toEqual(
+      expect.objectContaining({
+        id: 'chat-1',
+        name: 'Launch plan',
+        isActive: true,
+        isUnread: false,
+      })
+    )
+    expect(tasks[0]?.updatedAt.toISOString()).toBe('2026-04-11T10:00:00.000Z')
+  })
+
+  it('rejects invalid task metadata responses', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      jsonResponse({
+        success: true,
+        data: [
+          {
+            id: 123,
+            title: 'Broken',
+            updatedAt: '2026-04-11T10:00:00.000Z',
+            activeStreamId: null,
+            lastSeenAt: null,
+          },
+        ],
+      })
+    )
+
+    await expect(fetchTasks('ws-1')).rejects.toThrow(
+      'Invalid tasks response: data[0].id must be a string'
+    )
+  })
+
+  it('parses valid mothership chat history responses', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      jsonResponse({
+        success: true,
+        chat: {
+          id: 'chat-1',
+          title: 'Task history',
+          messages: [],
+          conversationId: 'stream-1',
+          resources: [{ type: 'file', id: 'file-1', title: 'Spec.md' }],
+          streamSnapshot: {
+            events: [],
+            previewSessions: [],
+            status: 'active',
+          },
+        },
+      })
+    )
+
+    const history = await fetchChatHistory('chat-1')
+
+    expect(history).toEqual({
+      id: 'chat-1',
+      title: 'Task history',
+      messages: [],
+      activeStreamId: 'stream-1',
+      resources: [{ type: 'file', id: 'file-1', title: 'Spec.md' }],
+      streamSnapshot: {
+        events: [],
+        previewSessions: [],
+        status: 'active',
+      },
+    })
+  })
+
+  it('rejects invalid fallback chat history responses', async () => {
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(new Response('Not found', { status: 404 }))
+      .mockResolvedValueOnce(
+        jsonResponse({
+          success: true,
+          chat: {
+            id: 'chat-1',
+            title: null,
+            messages: [],
+            activeStreamId: null,
+            resources: [{ type: 'bogus', id: 'resource-1', title: 'Broken' }],
+          },
+        })
+      )
+
+    await expect(fetchChatHistory('chat-1')).rejects.toThrow(
+      'Invalid copilot chat response: chat.resources[0].type is invalid'
+    )
+  })
+
+  it('rejects invalid chat resource mutation responses', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      jsonResponse({
+        success: true,
+      })
+    )
+
+    const mutation = useAddChatResource('chat-1') as unknown as {
+      mutationFn: (input: {
+        chatId: string
+        resource: MothershipResource
+      }) => Promise<{ resources: MothershipResource[] }>
+    }
+
+    await expect(
+      mutation.mutationFn({
+        chatId: 'chat-1',
+        resource: { type: 'file', id: 'file-1', title: 'Spec.md' },
+      })
+    ).rejects.toThrow('Invalid chat resources response: resources must be an array')
+  })
+})
diff --git a/apps/sim/hooks/queries/tasks.ts b/apps/sim/hooks/queries/tasks.ts
index 9cd1eab999a..e45429d613c 100644
--- a/apps/sim/hooks/queries/tasks.ts
+++ b/apps/sim/hooks/queries/tasks.ts
@@ -1,5 +1,12 @@
 import { keepPreviousData, useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
-import type { ChatContextKind, MothershipResource } from '@/app/workspace/[workspaceId]/home/types'
+import type { PersistedMessage } from '@/lib/copilot/chat/persisted-message'
+import { normalizeMessage } from '@/lib/copilot/chat/persisted-message'
+import {
+  type FilePreviewSession,
+  isFilePreviewSession,
+} from '@/lib/copilot/request/session/file-preview-session-contract'
+import { isStreamBatchEvent, type StreamBatchEvent } from '@/lib/copilot/request/session/types'
+import { type MothershipResource, MothershipResourceType } from '@/lib/copilot/resources/types'
 
 export interface TaskMetadata {
   id: string
@@ -9,71 +16,16 @@ export interface TaskMetadata {
   isUnread: boolean
 }
 
-export interface StreamSnapshot {
-  events: Array<{ eventId: number; streamId: string; event: Record<string, unknown> }>
-  status: string
-}
-
 export interface TaskChatHistory {
   id: string
   title: string | null
-  messages: TaskStoredMessage[]
+  messages: PersistedMessage[]
   activeStreamId: string | null
   resources: MothershipResource[]
-  streamSnapshot?: StreamSnapshot | null
-}
-
-export interface TaskStoredToolCall {
-  id: string
-  name: string
-  status: string
-  params?: Record<string, unknown>
-  result?: unknown
-  error?: string
-  durationMs?: number
-}
-
-export interface TaskStoredFileAttachment {
-  id: string
-  key: string
-  filename: string
-  media_type: string
-  size: number
-}
-
-export interface TaskStoredMessageContext {
-  kind: ChatContextKind
-  label: string
-  workflowId?: string
-  knowledgeId?: string
-  tableId?: string
-  fileId?: string
-  folderId?: string
-  chatId?: string
-}
-
-export interface TaskStoredMessage {
-  id: string
-  role: 'user' | 'assistant'
-  content: string
-  requestId?: string
-  toolCalls?: TaskStoredToolCall[]
-  contentBlocks?: TaskStoredContentBlock[]
-  fileAttachments?: TaskStoredFileAttachment[]
-  contexts?: TaskStoredMessageContext[]
-}
-
-export interface TaskStoredContentBlock {
-  type: string
-  content?: string
-  toolCall?: {
-    id?: string
-    name?: string
-    state?: string
-    params?: Record<string, unknown>
-    result?: { success: boolean; output?: unknown; error?: string }
-    display?: { text?: string }
-    calledBy?: string
+  streamSnapshot?: {
+    events: StreamBatchEvent[]
+    previewSessions: FilePreviewSession[]
+    status: string
   } | null
 }
 
@@ -89,32 +41,208 @@ interface TaskResponse {
   id: string
   title: string | null
   updatedAt: string
-  conversationId: string | null
+  activeStreamId: string | null
   lastSeenAt: string | null
 }
 
+type ChatHistorySource = 'copilot' | 'mothership'
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function assertValid(condition: unknown, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(message)
+  }
+}
+
+function isNullableString(value: unknown): value is string | null {
+  return value === null || typeof value === 'string'
+}
+
+function isValidDateString(value: unknown): value is string {
+  return typeof value === 'string' && !Number.isNaN(Date.parse(value))
+}
+
+function isResourceType(value: unknown): value is MothershipResource['type'] {
+  return (
+    typeof value === 'string' &&
+    Object.values(MothershipResourceType).some((type) => type === value)
+  )
+}
+
+function parseStreamSnapshot(value: unknown): TaskChatHistory['streamSnapshot'] {
+  if (!isRecord(value)) {
+    return null
+  }
+
+  const rawEvents = Array.isArray(value.events) ? value.events : []
+  const events: StreamBatchEvent[] = []
+  for (const entry of rawEvents) {
+    if (!isStreamBatchEvent(entry)) {
+      return null
+    }
+    events.push(entry)
+  }
+
+  const rawPreviewSessions = Array.isArray(value.previewSessions) ? value.previewSessions : []
+  const previewSessions: FilePreviewSession[] = []
+  for (const session of rawPreviewSessions) {
+    if (!isFilePreviewSession(session)) {
+      return null
+    }
+    previewSessions.push(session)
+  }
+
+  return {
+    events,
+    previewSessions,
+    status: typeof value.status === 'string' ? value.status : 'unknown',
+  }
+}
+
+function normalizeMessages(value: unknown): PersistedMessage[] {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  return value.filter(isRecord).map((message) => normalizeMessage(message))
+}
+
+function parseTaskResponse(value: unknown, index: number): TaskResponse {
+  assertValid(isRecord(value), `Invalid tasks response: data[${index}] must be an object`)
+  assertValid(
+    typeof value.id === 'string',
+    `Invalid tasks response: data[${index}].id must be a string`
+  )
+  assertValid(
+    isNullableString(value.title),
+    `Invalid tasks response: data[${index}].title must be a string or null`
+  )
+  assertValid(
+    isValidDateString(value.updatedAt),
+    `Invalid tasks response: data[${index}].updatedAt must be a valid date string`
+  )
+  assertValid(
+    isNullableString(value.activeStreamId),
+    `Invalid tasks response: data[${index}].activeStreamId must be a string or null`
+  )
+  assertValid(
+    isNullableString(value.lastSeenAt) &&
+      (value.lastSeenAt === null || isValidDateString(value.lastSeenAt)),
+    `Invalid tasks response: data[${index}].lastSeenAt must be a valid date string or null`
+  )
+
+  return {
+    id: value.id,
+    title: value.title,
+    updatedAt: value.updatedAt,
+    activeStreamId: value.activeStreamId,
+    lastSeenAt: value.lastSeenAt,
+  }
+}
+
+function parseTaskListResponse(value: unknown): TaskResponse[] {
+  assertValid(isRecord(value), 'Invalid tasks response: body must be an object')
+  assertValid(Array.isArray(value.data), 'Invalid tasks response: data must be an array')
+
+  return value.data.map((task, index) => parseTaskResponse(task, index))
+}
+
+function parseResource(value: unknown, context: string): MothershipResource {
+  assertValid(isRecord(value), `${context} must be an object`)
+  assertValid(isResourceType(value.type), `${context}.type is invalid`)
+  assertValid(typeof value.id === 'string', `${context}.id must be a string`)
+  assertValid(typeof value.title === 'string', `${context}.title must be a string`)
+
+  return {
+    type: value.type,
+    id: value.id,
+    title: value.title,
+  }
+}
+
+function parseResources(value: unknown, context: string): MothershipResource[] {
+  assertValid(Array.isArray(value), `${context} must be an array`)
+
+  return value.map((resource, index) => parseResource(resource, `${context}[${index}]`))
+}
+
+function parseStrictStreamSnapshot(
+  value: unknown,
+  context: string
+): TaskChatHistory['streamSnapshot'] {
+  if (value === undefined || value === null) {
+    return null
+  }
+
+  const snapshot = parseStreamSnapshot(value)
+  assertValid(snapshot !== null, `${context} is invalid`)
+  return snapshot
+}
+
+function parseChatHistory(value: unknown, source: ChatHistorySource): TaskChatHistory {
+  const responseContext = `Invalid ${source} chat response`
+  const chatContext = `${responseContext}: chat`
+
+  assertValid(isRecord(value), `${responseContext}: body must be an object`)
+  assertValid(isRecord(value.chat), `${chatContext} must be an object`)
+
+  const chat = value.chat
+  const activeStreamField = source === 'mothership' ? 'conversationId' : 'activeStreamId'
+  const activeStreamId = chat[activeStreamField]
+
+  assertValid(typeof chat.id === 'string', `${chatContext}.id must be a string`)
+  assertValid(isNullableString(chat.title), `${chatContext}.title must be a string or null`)
+  assertValid(Array.isArray(chat.messages), `${chatContext}.messages must be an array`)
+  assertValid(
+    isNullableString(activeStreamId),
+    `${chatContext}.${activeStreamField} must be a string or null`
+  )
+
+  return {
+    id: chat.id,
+    title: chat.title,
+    messages: normalizeMessages(chat.messages),
+    activeStreamId,
+    resources: parseResources(chat.resources, `${chatContext}.resources`),
+    streamSnapshot: parseStrictStreamSnapshot(chat.streamSnapshot, `${chatContext}.streamSnapshot`),
+  }
+}
+
+function parseChatResourcesResponse(value: unknown): { resources: MothershipResource[] } {
+  assertValid(isRecord(value), 'Invalid chat resources response: body must be an object')
+
+  return {
+    resources: parseResources(value.resources, 'Invalid chat resources response: resources'),
+  }
+}
+
 function mapTask(chat: TaskResponse): TaskMetadata {
   const updatedAt = new Date(chat.updatedAt)
   return {
     id: chat.id,
     name: chat.title ?? 'New task',
     updatedAt,
-    isActive: chat.conversationId !== null,
+    isActive: chat.activeStreamId !== null,
     isUnread:
-      chat.conversationId === null &&
+      chat.activeStreamId === null &&
       (chat.lastSeenAt === null || updatedAt > new Date(chat.lastSeenAt)),
   }
 }
 
-async function fetchTasks(workspaceId: string, signal?: AbortSignal): Promise<TaskMetadata[]> {
+export async function fetchTasks(
+  workspaceId: string,
+  signal?: AbortSignal
+): Promise<TaskMetadata[]> {
   const response = await fetch(`/api/mothership/chats?workspaceId=${workspaceId}`, { signal })
 
   if (!response.ok) {
     throw new Error('Failed to fetch tasks')
   }
 
-  const { data }: { data: TaskResponse[] } = await response.json()
-  return data.map(mapTask)
+  return parseTaskListResponse(await response.json()).map(mapTask)
 }
 
 /**
@@ -138,18 +266,10 @@ export async function fetchChatHistory(
   const mothershipRes = await fetch(`/api/mothership/chats/${chatId}`, { signal })
 
   if (mothershipRes.ok) {
-    const { chat } = await mothershipRes.json()
-    return {
-      id: chat.id,
-      title: chat.title,
-      messages: Array.isArray(chat.messages) ? chat.messages : [],
-      activeStreamId: chat.conversationId || null,
-      resources: Array.isArray(chat.resources) ? chat.resources : [],
-      streamSnapshot: chat.streamSnapshot || null,
-    }
+    return parseChatHistory(await mothershipRes.json(), 'mothership')
   }
 
-  const copilotRes = await fetch(`/api/copilot/chat?chatId=${encodeURIComponent(chatId)}`, {
+  const copilotRes = await fetch(`/api/mothership/chat?chatId=${encodeURIComponent(chatId)}`, {
     signal,
   })
 
@@ -157,15 +277,7 @@ export async function fetchChatHistory(
     throw new Error('Failed to load chat')
   }
 
-  const { chat } = await copilotRes.json()
-  return {
-    id: chat.id,
-    title: chat.title,
-    messages: Array.isArray(chat.messages) ? chat.messages : [],
-    activeStreamId: chat.conversationId || null,
-    resources: Array.isArray(chat.resources) ? chat.resources : [],
-    streamSnapshot: chat.streamSnapshot || null,
-  }
+  return parseChatHistory(await copilotRes.json(), 'copilot')
 }
 
 /**
@@ -267,13 +379,13 @@ async function addChatResource(params: {
   chatId: string
   resource: MothershipResource
 }): Promise<{ resources: MothershipResource[] }> {
-  const response = await fetch('/api/copilot/chat/resources', {
+  const response = await fetch('/api/mothership/chat/resources', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ chatId: params.chatId, resource: params.resource }),
   })
   if (!response.ok) throw new Error('Failed to add resource')
-  return response.json()
+  return parseChatResourcesResponse(await response.json())
 }
 
 export function useAddChatResource(chatId?: string) {
@@ -314,13 +426,13 @@ async function reorderChatResources(params: {
   chatId: string
   resources: MothershipResource[]
 }): Promise<{ resources: MothershipResource[] }> {
-  const response = await fetch('/api/copilot/chat/resources', {
+  const response = await fetch('/api/mothership/chat/resources', {
     method: 'PATCH',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ chatId: params.chatId, resources: params.resources }),
   })
   if (!response.ok) throw new Error('Failed to reorder resources')
-  return response.json()
+  return parseChatResourcesResponse(await response.json())
 }
 
 export function useReorderChatResources(chatId?: string) {
@@ -357,13 +469,13 @@ async function removeChatResource(params: {
   resourceType: string
   resourceId: string
 }): Promise<{ resources: MothershipResource[] }> {
-  const response = await fetch('/api/copilot/chat/resources', {
+  const response = await fetch('/api/mothership/chat/resources', {
     method: 'DELETE',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(params),
   })
   if (!response.ok) throw new Error('Failed to remove resource')
-  return response.json()
+  return parseChatResourcesResponse(await response.json())
 }
 
 export function useRemoveChatResource(chatId?: string) {
diff --git a/apps/sim/hooks/use-streaming-reveal.ts b/apps/sim/hooks/use-streaming-reveal.ts
deleted file mode 100644
index 8ce1beeac75..00000000000
--- a/apps/sim/hooks/use-streaming-reveal.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-'use client'
-
-import { useEffect, useRef, useState } from 'react'
-
-/**
- * Finds the last paragraph break (`\n\n`) that is not inside a fenced code
- * block. Returns the index immediately after the break — the start of the
- * next paragraph — so the caller can slice cleanly.
- */
-function findSafeSplitPoint(content: string): number {
-  let inCodeBlock = false
-  let lastSafeBreak = 0
-  let i = 0
-
-  while (i < content.length) {
-    if (content[i] === '`' && content[i + 1] === '`' && content[i + 2] === '`') {
-      inCodeBlock = !inCodeBlock
-      i += 3
-      continue
-    }
-
-    if (!inCodeBlock && content[i] === '\n' && content[i + 1] === '\n') {
-      lastSafeBreak = i + 2
-      i += 2
-      continue
-    }
-
-    i++
-  }
-
-  return lastSafeBreak
-}
-
-interface StreamingRevealResult {
-  /** Stable head — paragraphs that have fully arrived. Ideal for memoisation. */
-  committed: string
-  /** Active tail — the paragraph currently being streamed, animated on mount. */
-  incoming: string
-  /** Increments each time committed advances; use as React key to retrigger the fade animation. */
-  generation: number
-}
-
-/**
- * Splits streaming markdown into a stable *committed* head and an animated
- * *incoming* tail. The split always occurs at a paragraph boundary (`\n\n`)
- * that is outside fenced code blocks, so both halves are valid markdown.
- *
- * Committed content changes infrequently (only at paragraph breaks), making
- * it safe to wrap in `useMemo`. The incoming tail is small and re-renders at
- * the caller's throttle rate.
- *
- * The split is preserved after streaming ends to prevent layout shifts caused
- * by DOM restructuring. It only resets when content clears (new message).
- */
-export function useStreamingReveal(content: string, isStreaming: boolean): StreamingRevealResult {
-  const [committedEnd, setCommittedEnd] = useState(0)
-  const [generation, setGeneration] = useState(0)
-  const prevSplitRef = useRef(0)
-
-  useEffect(() => {
-    if (content.length === 0) {
-      prevSplitRef.current = 0
-      setCommittedEnd(0)
-      return
-    }
-
-    if (!isStreaming) return
-
-    const splitPoint = findSafeSplitPoint(content)
-    if (splitPoint > prevSplitRef.current) {
-      prevSplitRef.current = splitPoint
-      setCommittedEnd(splitPoint)
-      setGeneration((g) => g + 1)
-    }
-  }, [content, isStreaming])
-
-  if (!isStreaming) {
-    const preservedSplit = prevSplitRef.current
-
-    if (preservedSplit > 0 && preservedSplit < content.length) {
-      return {
-        committed: content.slice(0, preservedSplit),
-        incoming: content.slice(preservedSplit),
-        generation,
-      }
-    }
-
-    return { committed: content, incoming: '', generation }
-  }
-
-  if (committedEnd > 0 && committedEnd < content.length) {
-    return {
-      committed: content.slice(0, committedEnd),
-      incoming: content.slice(committedEnd),
-      generation,
-    }
-  }
-
-  // No paragraph split yet: keep the growing markdown in `incoming` only so ReactMarkdown
-  // re-parses one tail block (same as the paragraph-tail path). Putting everything in
-  // `committed` would re-render the full document every tick and makes tables jump.
-  if (committedEnd === 0 && content.length > 0) {
-    return { committed: '', incoming: content, generation }
-  }
-
-  return { committed: content, incoming: '', generation }
-}
diff --git a/apps/sim/hooks/use-streaming-text.ts b/apps/sim/hooks/use-streaming-text.ts
index 66ed1e343b3..369977a0f64 100644
--- a/apps/sim/hooks/use-streaming-text.ts
+++ b/apps/sim/hooks/use-streaming-text.ts
@@ -54,6 +54,7 @@ export function useStreamingText(target: string, isStreaming: boolean): string {
 
   useEffect(() => {
     if (isStreaming) return
+    if (revealedRef.current === target) return
     revealedRef.current = target
     lastTargetChangeAtRef.current = Date.now()
     lastTargetLengthRef.current = target.length
diff --git a/apps/sim/hooks/use-task-events.test.ts b/apps/sim/hooks/use-task-events.test.ts
new file mode 100644
index 00000000000..ac58e6cf27d
--- /dev/null
+++ b/apps/sim/hooks/use-task-events.test.ts
@@ -0,0 +1,62 @@
+/**
+ * @vitest-environment node
+ */
+
+import type { QueryClient } from '@tanstack/react-query'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { taskKeys } from '@/hooks/queries/tasks'
+import { handleTaskStatusEvent } from '@/hooks/use-task-events'
+
+describe('handleTaskStatusEvent', () => {
+  const queryClient = {
+    invalidateQueries: vi.fn().mockResolvedValue(undefined),
+  } satisfies Pick<QueryClient, 'invalidateQueries'>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('invalidates the task list and completed chat detail', () => {
+    handleTaskStatusEvent(
+      queryClient,
+      JSON.stringify({
+        chatId: 'chat-1',
+        type: 'completed',
+        timestamp: Date.now(),
+      })
+    )
+
+    expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(2)
+    expect(queryClient.invalidateQueries).toHaveBeenNthCalledWith(1, {
+      queryKey: taskKeys.lists(),
+    })
+    expect(queryClient.invalidateQueries).toHaveBeenNthCalledWith(2, {
+      queryKey: taskKeys.detail('chat-1'),
+    })
+  })
+
+  it('keeps list invalidation only for non-completed task events', () => {
+    handleTaskStatusEvent(
+      queryClient,
+      JSON.stringify({
+        chatId: 'chat-1',
+        type: 'started',
+        timestamp: Date.now(),
+      })
+    )
+
+    expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(1)
+    expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
+      queryKey: taskKeys.lists(),
+    })
+  })
+
+  it('preserves list invalidation when task event payload is invalid', () => {
+    handleTaskStatusEvent(queryClient, '{')
+
+    expect(queryClient.invalidateQueries).toHaveBeenCalledTimes(1)
+    expect(queryClient.invalidateQueries).toHaveBeenCalledWith({
+      queryKey: taskKeys.lists(),
+    })
+  })
+})
diff --git a/apps/sim/hooks/use-task-events.ts b/apps/sim/hooks/use-task-events.ts
index 14feb3813a8..04bff3df49c 100644
--- a/apps/sim/hooks/use-task-events.ts
+++ b/apps/sim/hooks/use-task-events.ts
@@ -1,12 +1,60 @@
 import { useEffect } from 'react'
 import { createLogger } from '@sim/logger'
+import type { QueryClient } from '@tanstack/react-query'
 import { useQueryClient } from '@tanstack/react-query'
 import { taskKeys } from '@/hooks/queries/tasks'
 
 const logger = createLogger('TaskEvents')
 
+interface TaskStatusEventPayload {
+  chatId?: string
+  type?: 'started' | 'completed' | 'created' | 'deleted' | 'renamed'
+}
+
+function parseTaskStatusEventPayload(data: unknown): TaskStatusEventPayload | null {
+  let parsed = data
+
+  if (typeof parsed === 'string') {
+    try {
+      parsed = JSON.parse(parsed)
+    } catch {
+      return null
+    }
+  }
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return null
+  }
+
+  const record = parsed as Record<string, unknown>
+
+  return {
+    ...(typeof record.chatId === 'string' ? { chatId: record.chatId } : {}),
+    ...(typeof record.type === 'string'
+      ? { type: record.type as TaskStatusEventPayload['type'] }
+      : {}),
+  }
+}
+
+export function handleTaskStatusEvent(
+  queryClient: Pick<QueryClient, 'invalidateQueries'>,
+  data: unknown
+): void {
+  queryClient.invalidateQueries({ queryKey: taskKeys.lists() })
+
+  const payload = parseTaskStatusEventPayload(data)
+  if (!payload) {
+    logger.warn('Received invalid task_status payload')
+    return
+  }
+
+  if (payload.type === 'completed' && payload.chatId) {
+    queryClient.invalidateQueries({ queryKey: taskKeys.detail(payload.chatId) })
+  }
+}
+
 /**
- * Subscribes to task status SSE events and invalidates the task list on changes.
+ * Subscribes to task status SSE events and invalidates task caches on changes.
  */
 export function useTaskEvents(workspaceId: string | undefined) {
   const queryClient = useQueryClient()
@@ -18,8 +66,8 @@ export function useTaskEvents(workspaceId: string | undefined) {
       `/api/mothership/events?workspaceId=${encodeURIComponent(workspaceId)}`
     )
 
-    eventSource.addEventListener('task_status', () => {
-      queryClient.invalidateQueries({ queryKey: taskKeys.lists() })
+    eventSource.addEventListener('task_status', (event) => {
+      handleTaskStatusEvent(queryClient, event instanceof MessageEvent ? event.data : undefined)
     })
 
     eventSource.onerror = () => {
diff --git a/apps/sim/lib/billing/workspace-concurrency.test.ts b/apps/sim/lib/billing/workspace-concurrency.test.ts
deleted file mode 100644
index 462e24a8e06..00000000000
--- a/apps/sim/lib/billing/workspace-concurrency.test.ts
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const {
-  mockGetHighestPrioritySubscription,
-  mockGetWorkspaceBilledAccountUserId,
-  mockFeatureFlags,
-  mockRedisGet,
-  mockRedisSet,
-  mockRedisDel,
-  mockRedisKeys,
-  mockGetRedisClient,
-} = vi.hoisted(() => ({
-  mockGetHighestPrioritySubscription: vi.fn(),
-  mockGetWorkspaceBilledAccountUserId: vi.fn(),
-  mockFeatureFlags: {
-    isBillingEnabled: true,
-  },
-  mockRedisGet: vi.fn(),
-  mockRedisSet: vi.fn(),
-  mockRedisDel: vi.fn(),
-  mockRedisKeys: vi.fn(),
-  mockGetRedisClient: vi.fn(),
-}))
-
-vi.mock('@sim/logger', () => ({
-  createLogger: () => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-  }),
-}))
-
-vi.mock('@/lib/billing/core/plan', () => ({
-  getHighestPrioritySubscription: mockGetHighestPrioritySubscription,
-}))
-
-vi.mock('@/lib/workspaces/utils', () => ({
-  getWorkspaceBilledAccountUserId: mockGetWorkspaceBilledAccountUserId,
-}))
-
-vi.mock('@/lib/core/config/redis', () => ({
-  getRedisClient: mockGetRedisClient,
-}))
-
-vi.mock('@/lib/core/config/feature-flags', () => mockFeatureFlags)
-
-import {
-  getWorkspaceConcurrencyLimit,
-  resetWorkspaceConcurrencyLimitCache,
-} from '@/lib/billing/workspace-concurrency'
-
-describe('workspace concurrency billing', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockFeatureFlags.isBillingEnabled = true
-
-    mockRedisGet.mockResolvedValue(null)
-    mockRedisSet.mockResolvedValue('OK')
-    mockRedisDel.mockResolvedValue(1)
-    mockRedisKeys.mockResolvedValue([])
-    mockGetRedisClient.mockReturnValue({
-      get: mockRedisGet,
-      set: mockRedisSet,
-      del: mockRedisDel,
-      keys: mockRedisKeys,
-    })
-  })
-
-  it('returns free tier when no billed account exists', async () => {
-    mockGetWorkspaceBilledAccountUserId.mockResolvedValue(null)
-
-    await expect(getWorkspaceConcurrencyLimit('workspace-1')).resolves.toBe(5)
-  })
-
-  it('returns pro limit for pro billing accounts', async () => {
-    mockGetWorkspaceBilledAccountUserId.mockResolvedValue('user-1')
-    mockGetHighestPrioritySubscription.mockResolvedValue({
-      plan: 'pro_6000',
-      metadata: null,
-    })
-
-    await expect(getWorkspaceConcurrencyLimit('workspace-1')).resolves.toBe(50)
-  })
-
-  it('returns max limit for max plan tiers', async () => {
-    mockGetWorkspaceBilledAccountUserId.mockResolvedValue('user-1')
-    mockGetHighestPrioritySubscription.mockResolvedValue({
-      plan: 'pro_25000',
-      metadata: null,
-    })
-
-    await expect(getWorkspaceConcurrencyLimit('workspace-1')).resolves.toBe(200)
-  })
-
-  it('returns max limit for legacy team plans', async () => {
-    mockGetWorkspaceBilledAccountUserId.mockResolvedValue('user-1')
-    mockGetHighestPrioritySubscription.mockResolvedValue({
-      plan: 'team',
-      metadata: null,
-    })
-
-    await expect(getWorkspaceConcurrencyLimit('workspace-1')).resolves.toBe(200)
-  })
-
-  it('returns enterprise metadata override when present', async () => {
-    mockGetWorkspaceBilledAccountUserId.mockResolvedValue('user-1')
-    mockGetHighestPrioritySubscription.mockResolvedValue({
-      plan: 'enterprise',
-      metadata: {
-        workspaceConcurrencyLimit: '350',
-      },
-    })
-
-    await expect(getWorkspaceConcurrencyLimit('workspace-1')).resolves.toBe(350)
-  })
-
-  it('uses free-tier limit when billing is disabled', async () => {
-    mockFeatureFlags.isBillingEnabled = false
-    mockGetWorkspaceBilledAccountUserId.mockResolvedValue('user-1')
-    mockGetHighestPrioritySubscription.mockResolvedValue({
-      plan: 'pro_25000',
-      metadata: {
-        workspaceConcurrencyLimit: 999,
-      },
-    })
-
-    await expect(getWorkspaceConcurrencyLimit('workspace-1')).resolves.toBe(5)
-  })
-
-  it('uses redis cache when available', async () => {
-    mockRedisGet.mockResolvedValueOnce('123')
-
-    await expect(getWorkspaceConcurrencyLimit('workspace-1')).resolves.toBe(123)
-    expect(mockGetWorkspaceBilledAccountUserId).not.toHaveBeenCalled()
-  })
-
-  it('can clear a specific workspace cache entry', async () => {
-    await resetWorkspaceConcurrencyLimitCache('workspace-1')
-
-    expect(mockRedisDel).toHaveBeenCalledWith('workspace-concurrency-limit:workspace-1')
-  })
-})
diff --git a/apps/sim/lib/billing/workspace-concurrency.ts b/apps/sim/lib/billing/workspace-concurrency.ts
deleted file mode 100644
index acb07169f91..00000000000
--- a/apps/sim/lib/billing/workspace-concurrency.ts
+++ /dev/null
@@ -1,170 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
-import { getPlanTierCredits, isEnterprise, isPro, isTeam } from '@/lib/billing/plan-helpers'
-import { parseEnterpriseWorkspaceConcurrencyMetadata } from '@/lib/billing/types'
-import { env } from '@/lib/core/config/env'
-import { isBillingEnabled } from '@/lib/core/config/feature-flags'
-import { getRedisClient } from '@/lib/core/config/redis'
-import { getWorkspaceBilledAccountUserId } from '@/lib/workspaces/utils'
-
-const logger = createLogger('WorkspaceConcurrencyBilling')
-
-const CACHE_TTL_MS = 60_000
-const CACHE_TTL_SECONDS = Math.floor(CACHE_TTL_MS / 1000)
-
-interface CacheEntry {
-  value: number
-  expiresAt: number
-}
-
-const inMemoryConcurrencyCache = new Map<string, CacheEntry>()
-
-function cacheKey(workspaceId: string): string {
-  return `workspace-concurrency-limit:${workspaceId}`
-}
-
-function parsePositiveLimit(value: unknown): number | null {
-  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
-    return Math.floor(value)
-  }
-
-  if (typeof value === 'string') {
-    const parsed = Number.parseInt(value, 10)
-    if (Number.isFinite(parsed) && parsed > 0) {
-      return parsed
-    }
-  }
-
-  return null
-}
-
-function getFreeConcurrencyLimit(): number {
-  return Number.parseInt(env.WORKSPACE_CONCURRENCY_FREE, 10) || 5
-}
-
-function getProConcurrencyLimit(): number {
-  return Number.parseInt(env.WORKSPACE_CONCURRENCY_PRO, 10) || 50
-}
-
-function getTeamConcurrencyLimit(): number {
-  return Number.parseInt(env.WORKSPACE_CONCURRENCY_TEAM, 10) || 200
-}
-
-function getEnterpriseDefaultConcurrencyLimit(): number {
-  return Number.parseInt(env.WORKSPACE_CONCURRENCY_ENTERPRISE, 10) || 200
-}
-
-function getEnterpriseConcurrencyLimit(metadata: unknown): number {
-  const enterpriseMetadata = parseEnterpriseWorkspaceConcurrencyMetadata(metadata)
-  return enterpriseMetadata?.workspaceConcurrencyLimit ?? getEnterpriseDefaultConcurrencyLimit()
-}
-
-function getPlanConcurrencyLimit(plan: string | null | undefined, metadata: unknown): number {
-  if (!isBillingEnabled) {
-    return getFreeConcurrencyLimit()
-  }
-
-  if (!plan) {
-    return getFreeConcurrencyLimit()
-  }
-
-  if (isEnterprise(plan)) {
-    return getEnterpriseConcurrencyLimit(metadata)
-  }
-
-  if (isTeam(plan)) {
-    return getTeamConcurrencyLimit()
-  }
-
-  const credits = getPlanTierCredits(plan)
-  if (credits >= 25_000) {
-    return getTeamConcurrencyLimit()
-  }
-
-  if (isPro(plan)) {
-    return getProConcurrencyLimit()
-  }
-
-  return getFreeConcurrencyLimit()
-}
-
-export async function getWorkspaceConcurrencyLimit(workspaceId: string): Promise<number> {
-  const redis = getRedisClient()
-
-  if (redis) {
-    const cached = await redis.get(cacheKey(workspaceId))
-    const cachedValue = parsePositiveLimit(cached)
-    if (cachedValue !== null) {
-      return cachedValue
-    }
-  } else {
-    const cached = inMemoryConcurrencyCache.get(workspaceId)
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.value
-    }
-  }
-
-  try {
-    const billedAccountUserId = await getWorkspaceBilledAccountUserId(workspaceId)
-    if (!billedAccountUserId) {
-      if (redis) {
-        await redis.set(
-          cacheKey(workspaceId),
-          String(getFreeConcurrencyLimit()),
-          'EX',
-          CACHE_TTL_SECONDS
-        )
-      } else {
-        inMemoryConcurrencyCache.set(workspaceId, {
-          value: getFreeConcurrencyLimit(),
-          expiresAt: Date.now() + CACHE_TTL_MS,
-        })
-      }
-      return getFreeConcurrencyLimit()
-    }
-
-    const subscription = await getHighestPrioritySubscription(billedAccountUserId)
-    const limit = getPlanConcurrencyLimit(subscription?.plan, subscription?.metadata)
-
-    if (redis) {
-      await redis.set(cacheKey(workspaceId), String(limit), 'EX', CACHE_TTL_SECONDS)
-    } else {
-      inMemoryConcurrencyCache.set(workspaceId, {
-        value: limit,
-        expiresAt: Date.now() + CACHE_TTL_MS,
-      })
-    }
-
-    return limit
-  } catch (error) {
-    logger.error('Failed to resolve workspace concurrency limit, using free tier', {
-      workspaceId,
-      error,
-    })
-
-    return getFreeConcurrencyLimit()
-  }
-}
-
-export async function resetWorkspaceConcurrencyLimitCache(workspaceId?: string): Promise<void> {
-  if (!workspaceId) {
-    inMemoryConcurrencyCache.clear()
-  } else {
-    inMemoryConcurrencyCache.delete(workspaceId)
-  }
-
-  const redis = getRedisClient()
-  if (!redis) {
-    return
-  }
-
-  if (workspaceId) {
-    await redis.del(cacheKey(workspaceId))
-    return
-  }
-
-  const keys = await redis.keys('workspace-concurrency-limit:*')
-  if (keys.length > 0) {
-    await redis.del(...keys)
-  }
-}
diff --git a/apps/sim/lib/copilot/async-runs/lifecycle.test.ts b/apps/sim/lib/copilot/async-runs/lifecycle.test.ts
index bc6668debf6..8cd4fd872e7 100644
--- a/apps/sim/lib/copilot/async-runs/lifecycle.test.ts
+++ b/apps/sim/lib/copilot/async-runs/lifecycle.test.ts
@@ -4,8 +4,10 @@
 
 import { describe, expect, it } from 'vitest'
 import {
+  ASYNC_TOOL_CONFIRMATION_STATUS,
   ASYNC_TOOL_STATUS,
-  inferDeliveredAsyncSuccess,
+  isAsyncEphemeralConfirmationStatus,
+  isAsyncTerminalConfirmationStatus,
   isDeliveredAsyncStatus,
   isTerminalAsyncStatus,
 } from './lifecycle'
@@ -20,10 +22,17 @@ describe('async tool lifecycle helpers', () => {
     expect(isTerminalAsyncStatus(ASYNC_TOOL_STATUS.delivered)).toBe(false)
   })
 
-  it('treats delivered rows as success unless durable error/cancel markers say otherwise', () => {
+  it('treats delivered rows as distinct from terminal execution states', () => {
     expect(isDeliveredAsyncStatus(ASYNC_TOOL_STATUS.delivered)).toBe(true)
-    expect(inferDeliveredAsyncSuccess({ result: { ok: true }, error: null })).toBe(true)
-    expect(inferDeliveredAsyncSuccess({ result: { cancelled: true }, error: null })).toBe(false)
-    expect(inferDeliveredAsyncSuccess({ result: null, error: 'tool failed' })).toBe(false)
+  })
+
+  it('distinguishes background from terminal completion statuses', () => {
+    expect(isAsyncEphemeralConfirmationStatus(ASYNC_TOOL_CONFIRMATION_STATUS.background)).toBe(true)
+    expect(isAsyncEphemeralConfirmationStatus(ASYNC_TOOL_CONFIRMATION_STATUS.success)).toBe(false)
+
+    expect(isAsyncTerminalConfirmationStatus(ASYNC_TOOL_CONFIRMATION_STATUS.success)).toBe(true)
+    expect(isAsyncTerminalConfirmationStatus(ASYNC_TOOL_CONFIRMATION_STATUS.error)).toBe(true)
+    expect(isAsyncTerminalConfirmationStatus(ASYNC_TOOL_CONFIRMATION_STATUS.cancelled)).toBe(true)
+    expect(isAsyncTerminalConfirmationStatus(ASYNC_TOOL_CONFIRMATION_STATUS.background)).toBe(true)
   })
 })
diff --git a/apps/sim/lib/copilot/async-runs/lifecycle.ts b/apps/sim/lib/copilot/async-runs/lifecycle.ts
index 949ff773247..e54b2f1900a 100644
--- a/apps/sim/lib/copilot/async-runs/lifecycle.ts
+++ b/apps/sim/lib/copilot/async-runs/lifecycle.ts
@@ -1,13 +1,10 @@
 import type { CopilotAsyncToolStatus } from '@sim/db/schema'
+import {
+  MothershipStreamV1AsyncToolRecordStatus,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
 
-export const ASYNC_TOOL_STATUS = {
-  pending: 'pending',
-  running: 'running',
-  completed: 'completed',
-  failed: 'failed',
-  cancelled: 'cancelled',
-  delivered: 'delivered',
-} as const
+export const ASYNC_TOOL_STATUS = MothershipStreamV1AsyncToolRecordStatus
 
 export type AsyncLifecycleStatus =
   | typeof ASYNC_TOOL_STATUS.pending
@@ -21,13 +18,40 @@ export type AsyncTerminalStatus =
   | typeof ASYNC_TOOL_STATUS.failed
   | typeof ASYNC_TOOL_STATUS.cancelled
 
-export type AsyncFinishedStatus = AsyncTerminalStatus | typeof ASYNC_TOOL_STATUS.delivered
+/**
+ * Confirmation statuses sent on the request-local async tool confirmation channel.
+ *
+ * `background` is still emitted by the current browser workflow runtime on `pagehide`.
+ */
+export const ASYNC_TOOL_CONFIRMATION_STATUS = {
+  background: 'background',
+  success: MothershipStreamV1ToolOutcome.success,
+  error: MothershipStreamV1ToolOutcome.error,
+  cancelled: MothershipStreamV1ToolOutcome.cancelled,
+} as const
+
+export type AsyncConfirmationStatus =
+  (typeof ASYNC_TOOL_CONFIRMATION_STATUS)[keyof typeof ASYNC_TOOL_CONFIRMATION_STATUS]
+
+export type AsyncTerminalConfirmationStatus = AsyncConfirmationStatus
+
+export type AsyncConfirmationProgressStatus =
+  | typeof ASYNC_TOOL_STATUS.pending
+  | typeof ASYNC_TOOL_STATUS.running
+
+export type AsyncEphemeralConfirmationStatus = typeof ASYNC_TOOL_CONFIRMATION_STATUS.background
+
+export type AsyncConfirmationStateStatus = AsyncConfirmationProgressStatus | AsyncConfirmationStatus
+
+export type AsyncPromiseStatus = typeof ASYNC_TOOL_STATUS.running | AsyncTerminalConfirmationStatus
+
+export type AsyncCompletionData = unknown
 
 export interface AsyncCompletionEnvelope {
   toolCallId: string
-  status: string
+  status: AsyncConfirmationStatus
   message?: string
-  data?: Record<string, unknown>
+  data?: AsyncCompletionData
   runId?: string
   checkpointId?: string
   executionId?: string
@@ -35,6 +59,28 @@ export interface AsyncCompletionEnvelope {
   timestamp?: string
 }
 
+export type AsyncCompletionSnapshot = Pick<
+  AsyncCompletionEnvelope,
+  'status' | 'message' | 'data' | 'timestamp'
+>
+
+export interface AsyncTerminalCompletionSnapshot extends AsyncCompletionSnapshot {
+  status: AsyncTerminalConfirmationStatus
+}
+
+export interface AsyncConfirmationState {
+  status: AsyncConfirmationStateStatus
+  message?: string
+  data?: AsyncCompletionData
+  timestamp?: string
+}
+
+export interface AsyncCompletionSignal {
+  status: AsyncPromiseStatus
+  message?: string
+  data?: AsyncCompletionData
+}
+
 export function isTerminalAsyncStatus(
   status: CopilotAsyncToolStatus | AsyncLifecycleStatus | string | null | undefined
 ): status is AsyncTerminalStatus {
@@ -51,15 +97,19 @@ export function isDeliveredAsyncStatus(
   return status === ASYNC_TOOL_STATUS.delivered
 }
 
-export function inferDeliveredAsyncSuccess(input: {
-  result?: Record<string, unknown> | null
-  error?: string | null
-}) {
-  if (input.error) return false
-  const result = input.result ?? undefined
-  if (!result) return true
-  if (result.cancelled === true || result.cancelledByUser === true) return false
-  if (typeof result.reason === 'string' && result.reason === 'user_cancelled') return false
-  if (typeof result.error === 'string') return false
-  return true
+export function isAsyncTerminalConfirmationStatus(
+  status: string | null | undefined
+): status is AsyncTerminalConfirmationStatus {
+  return (
+    status === ASYNC_TOOL_CONFIRMATION_STATUS.background ||
+    status === ASYNC_TOOL_CONFIRMATION_STATUS.success ||
+    status === ASYNC_TOOL_CONFIRMATION_STATUS.error ||
+    status === ASYNC_TOOL_CONFIRMATION_STATUS.cancelled
+  )
+}
+
+export function isAsyncEphemeralConfirmationStatus(
+  status: string | null | undefined
+): status is AsyncEphemeralConfirmationStatus {
+  return status === ASYNC_TOOL_CONFIRMATION_STATUS.background
 }
diff --git a/apps/sim/lib/copilot/async-runs/repository.ts b/apps/sim/lib/copilot/async-runs/repository.ts
index acea65f6103..c18d27cbbec 100644
--- a/apps/sim/lib/copilot/async-runs/repository.ts
+++ b/apps/sim/lib/copilot/async-runs/repository.ts
@@ -8,7 +8,12 @@ import {
 } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq, inArray, isNull } from 'drizzle-orm'
-import { ASYNC_TOOL_STATUS, isDeliveredAsyncStatus, isTerminalAsyncStatus } from './lifecycle'
+import {
+  ASYNC_TOOL_STATUS,
+  type AsyncCompletionData,
+  isDeliveredAsyncStatus,
+  isTerminalAsyncStatus,
+} from './lifecycle'
 
 const logger = createLogger('CopilotAsyncRunsRepo')
 
@@ -203,7 +208,7 @@ export async function markAsyncToolStatus(
   updates: {
     claimedBy?: string | null
     claimedAt?: Date | null
-    result?: Record<string, unknown> | null
+    result?: AsyncCompletionData | null
     error?: string | null
     completedAt?: Date | null
   } = {}
@@ -239,7 +244,7 @@ export async function markAsyncToolRunning(toolCallId: string, claimedBy: string
 export async function completeAsyncToolCall(input: {
   toolCallId: string
   status: Extract<CopilotAsyncToolStatus, 'completed' | 'failed' | 'cancelled'>
-  result?: Record<string, unknown> | null
+  result?: AsyncCompletionData | null
   error?: string | null
 }) {
   const existing = await getAsyncToolCall(input.toolCallId)
diff --git a/apps/sim/lib/copilot/chat-context.ts b/apps/sim/lib/copilot/chat-context.ts
deleted file mode 100644
index f475b3b2802..00000000000
--- a/apps/sim/lib/copilot/chat-context.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { CopilotFiles } from '@/lib/uploads'
-import { createFileContent } from '@/lib/uploads/utils/file-utils'
-
-const logger = createLogger('CopilotChatContext')
-
-export interface FileAttachmentInput {
-  id: string
-  key: string
-  name?: string
-  filename?: string
-  mimeType?: string
-  media_type?: string
-  size: number
-}
-
-export interface FileContent {
-  type: string
-  [key: string]: unknown
-}
-
-/**
- * Process file attachments into content for the payload.
- */
-export async function processFileAttachments(
-  fileAttachments: FileAttachmentInput[],
-  userId: string
-): Promise<FileContent[]> {
-  if (!Array.isArray(fileAttachments) || fileAttachments.length === 0) return []
-
-  const processedFileContents: FileContent[] = []
-  const requestId = `copilot-${userId}-${Date.now()}`
-  const processedAttachments = await CopilotFiles.processCopilotAttachments(
-    fileAttachments as Parameters<typeof CopilotFiles.processCopilotAttachments>[0],
-    requestId
-  )
-
-  for (const { buffer, attachment } of processedAttachments) {
-    const fileContent = createFileContent(buffer, attachment.media_type)
-    if (fileContent) {
-      const enriched: FileContent = { ...fileContent, filename: attachment.filename }
-      processedFileContents.push(enriched)
-    }
-  }
-
-  logger.debug('Processed file attachments for payload', {
-    userId,
-    inputCount: fileAttachments.length,
-    outputCount: processedFileContents.length,
-  })
-
-  return processedFileContents
-}
diff --git a/apps/sim/lib/copilot/chat-streaming.test.ts b/apps/sim/lib/copilot/chat-streaming.test.ts
deleted file mode 100644
index b0e05ed445a..00000000000
--- a/apps/sim/lib/copilot/chat-streaming.test.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * @vitest-environment node
- */
-
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const {
-  orchestrateCopilotStream,
-  createRunSegment,
-  updateRunStatus,
-  resetStreamBuffer,
-  setStreamMeta,
-  createStreamEventWriter,
-} = vi.hoisted(() => ({
-  orchestrateCopilotStream: vi.fn(),
-  createRunSegment: vi.fn(),
-  updateRunStatus: vi.fn(),
-  resetStreamBuffer: vi.fn(),
-  setStreamMeta: vi.fn(),
-  createStreamEventWriter: vi.fn(),
-}))
-
-vi.mock('@/lib/copilot/orchestrator', () => ({
-  orchestrateCopilotStream,
-}))
-
-vi.mock('@/lib/copilot/async-runs/repository', () => ({
-  createRunSegment,
-  updateRunStatus,
-}))
-
-vi.mock('@/lib/copilot/orchestrator/stream/buffer', () => ({
-  createStreamEventWriter,
-  resetStreamBuffer,
-  setStreamMeta,
-}))
-
-vi.mock('@sim/db', () => ({
-  db: {
-    update: vi.fn(() => ({
-      set: vi.fn(() => ({
-        where: vi.fn(),
-      })),
-    })),
-  },
-}))
-
-vi.mock('@/lib/copilot/task-events', () => ({
-  taskPubSub: null,
-}))
-
-import { createSSEStream } from '@/lib/copilot/chat-streaming'
-
-async function drainStream(stream: ReadableStream) {
-  const reader = stream.getReader()
-  while (true) {
-    const { done } = await reader.read()
-    if (done) break
-  }
-}
-
-describe('createSSEStream terminal error handling', () => {
-  const write = vi.fn().mockResolvedValue({ eventId: 1, streamId: 'stream-1', event: {} })
-  const flush = vi.fn().mockResolvedValue(undefined)
-  const close = vi.fn().mockResolvedValue(undefined)
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    write.mockResolvedValue({ eventId: 1, streamId: 'stream-1', event: {} })
-    flush.mockResolvedValue(undefined)
-    close.mockResolvedValue(undefined)
-    createStreamEventWriter.mockReturnValue({ write, flush, close })
-    resetStreamBuffer.mockResolvedValue(undefined)
-    setStreamMeta.mockResolvedValue(undefined)
-    createRunSegment.mockResolvedValue(null)
-    updateRunStatus.mockResolvedValue(null)
-  })
-
-  it('writes a terminal error event before close when orchestration returns success=false', async () => {
-    orchestrateCopilotStream.mockResolvedValue({
-      success: false,
-      error: 'resume failed',
-      content: '',
-      contentBlocks: [],
-      toolCalls: [],
-    })
-
-    const stream = createSSEStream({
-      requestPayload: { message: 'hello' },
-      userId: 'user-1',
-      streamId: 'stream-1',
-      executionId: 'exec-1',
-      runId: 'run-1',
-      currentChat: null,
-      isNewChat: false,
-      message: 'hello',
-      titleModel: 'gpt-5.4',
-      requestId: 'req-1',
-      orchestrateOptions: {},
-    })
-
-    await drainStream(stream)
-
-    expect(write).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'error',
-        error: 'resume failed',
-      })
-    )
-    expect(write.mock.invocationCallOrder.at(-1)).toBeLessThan(close.mock.invocationCallOrder[0])
-  })
-
-  it('writes the thrown terminal error event before close for replay durability', async () => {
-    orchestrateCopilotStream.mockRejectedValue(new Error('kaboom'))
-
-    const stream = createSSEStream({
-      requestPayload: { message: 'hello' },
-      userId: 'user-1',
-      streamId: 'stream-1',
-      executionId: 'exec-1',
-      runId: 'run-1',
-      currentChat: null,
-      isNewChat: false,
-      message: 'hello',
-      titleModel: 'gpt-5.4',
-      requestId: 'req-1',
-      orchestrateOptions: {},
-    })
-
-    await drainStream(stream)
-
-    expect(write).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'error',
-        error: 'kaboom',
-      })
-    )
-    expect(write.mock.invocationCallOrder.at(-1)).toBeLessThan(close.mock.invocationCallOrder[0])
-  })
-})
diff --git a/apps/sim/lib/copilot/chat-streaming.ts b/apps/sim/lib/copilot/chat-streaming.ts
deleted file mode 100644
index 5779d20f65f..00000000000
--- a/apps/sim/lib/copilot/chat-streaming.ts
+++ /dev/null
@@ -1,579 +0,0 @@
-import { db } from '@sim/db'
-import { copilotChats } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import { createRunSegment, updateRunStatus } from '@/lib/copilot/async-runs/repository'
-import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import type { OrchestrateStreamOptions } from '@/lib/copilot/orchestrator'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import {
-  createStreamEventWriter,
-  getStreamMeta,
-  resetStreamBuffer,
-  setStreamMeta,
-} from '@/lib/copilot/orchestrator/stream/buffer'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { env } from '@/lib/core/config/env'
-import { acquireLock, getRedisClient, releaseLock } from '@/lib/core/config/redis'
-import { SSE_HEADERS } from '@/lib/core/utils/sse'
-
-const logger = createLogger('CopilotChatStreaming')
-const CHAT_STREAM_LOCK_TTL_SECONDS = 2 * 60 * 60
-const STREAM_ABORT_TTL_SECONDS = 10 * 60
-const STREAM_ABORT_POLL_MS = 1000
-
-interface ActiveStreamEntry {
-  abortController: AbortController
-  userStopController: AbortController
-}
-
-const activeStreams = new Map<string, ActiveStreamEntry>()
-
-// Tracks in-flight streams by chatId so that a subsequent request for the
-// same chat can force-abort the previous stream and wait for it to settle
-// before forwarding to Go.
-const pendingChatStreams = new Map<
-  string,
-  { promise: Promise<void>; resolve: () => void; streamId: string }
->()
-
-function registerPendingChatStream(chatId: string, streamId: string): void {
-  if (pendingChatStreams.has(chatId)) {
-    logger.warn(`registerPendingChatStream: overwriting existing entry for chatId ${chatId}`)
-  }
-  let resolve!: () => void
-  const promise = new Promise<void>((r) => {
-    resolve = r
-  })
-  pendingChatStreams.set(chatId, { promise, resolve, streamId })
-}
-
-function resolvePendingChatStream(chatId: string, streamId: string): void {
-  const entry = pendingChatStreams.get(chatId)
-  if (entry && entry.streamId === streamId) {
-    entry.resolve()
-    pendingChatStreams.delete(chatId)
-  }
-}
-
-function getChatStreamLockKey(chatId: string): string {
-  return `copilot:chat-stream-lock:${chatId}`
-}
-
-function getStreamAbortKey(streamId: string): string {
-  return `copilot:stream-abort:${streamId}`
-}
-
-/**
- * Wait for any in-flight stream on `chatId` to settle without force-aborting it.
- * Returns true when no stream is active (or it settles in time), false on timeout.
- */
-export async function waitForPendingChatStream(
-  chatId: string,
-  timeoutMs = 5_000,
-  expectedStreamId?: string
-): Promise<boolean> {
-  const redis = getRedisClient()
-  const deadline = Date.now() + timeoutMs
-
-  for (;;) {
-    const entry = pendingChatStreams.get(chatId)
-    const localPending = !!entry && (!expectedStreamId || entry.streamId === expectedStreamId)
-
-    if (redis) {
-      try {
-        const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
-        const lockReleased =
-          !ownerStreamId || (expectedStreamId !== undefined && ownerStreamId !== expectedStreamId)
-        if (!localPending && lockReleased) {
-          return true
-        }
-      } catch (error) {
-        logger.warn('Failed to check distributed chat stream lock while waiting', {
-          chatId,
-          expectedStreamId,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    } else if (!localPending) {
-      return true
-    }
-
-    if (Date.now() >= deadline) return false
-    await new Promise((resolve) => setTimeout(resolve, 200))
-  }
-}
-
-export async function releasePendingChatStream(chatId: string, streamId: string): Promise<void> {
-  const redis = getRedisClient()
-  if (redis) {
-    await releaseLock(getChatStreamLockKey(chatId), streamId).catch(() => false)
-  }
-  resolvePendingChatStream(chatId, streamId)
-}
-
-export async function acquirePendingChatStream(
-  chatId: string,
-  streamId: string,
-  timeoutMs = 5_000
-): Promise<boolean> {
-  const redis = getRedisClient()
-  if (redis) {
-    const deadline = Date.now() + timeoutMs
-    for (;;) {
-      try {
-        const acquired = await acquireLock(
-          getChatStreamLockKey(chatId),
-          streamId,
-          CHAT_STREAM_LOCK_TTL_SECONDS
-        )
-        if (acquired) {
-          registerPendingChatStream(chatId, streamId)
-          return true
-        }
-        if (!pendingChatStreams.has(chatId)) {
-          const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
-          if (ownerStreamId) {
-            const ownerMeta = await getStreamMeta(ownerStreamId)
-            const ownerTerminal =
-              ownerMeta?.status === 'complete' ||
-              ownerMeta?.status === 'error' ||
-              ownerMeta?.status === 'cancelled'
-            if (ownerTerminal) {
-              await releaseLock(getChatStreamLockKey(chatId), ownerStreamId).catch(() => false)
-              continue
-            }
-          }
-        }
-      } catch (error) {
-        logger.warn('Distributed chat stream lock failed; retrying distributed coordination', {
-          chatId,
-          streamId,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-      if (Date.now() >= deadline) return false
-      await new Promise((resolve) => setTimeout(resolve, 200))
-    }
-  }
-
-  for (;;) {
-    const existing = pendingChatStreams.get(chatId)
-    if (!existing) {
-      registerPendingChatStream(chatId, streamId)
-      return true
-    }
-
-    const settled = await Promise.race([
-      existing.promise.then(() => true),
-      new Promise<boolean>((r) => setTimeout(() => r(false), timeoutMs)),
-    ])
-    if (!settled) return false
-  }
-}
-
-export async function abortActiveStream(streamId: string): Promise<boolean> {
-  const redis = getRedisClient()
-  let published = false
-  if (redis) {
-    try {
-      await redis.set(getStreamAbortKey(streamId), '1', 'EX', STREAM_ABORT_TTL_SECONDS)
-      published = true
-    } catch (error) {
-      logger.warn('Failed to publish distributed stream abort', {
-        streamId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-  }
-  const entry = activeStreams.get(streamId)
-  if (!entry) return published
-  entry.userStopController.abort()
-  entry.abortController.abort()
-  activeStreams.delete(streamId)
-  return true
-}
-
-const FLUSH_EVENT_TYPES = new Set([
-  'tool_call',
-  'tool_result',
-  'tool_error',
-  'subagent_end',
-  'structured_result',
-  'subagent_result',
-  'done',
-  'error',
-])
-
-export async function requestChatTitle(params: {
-  message: string
-  model: string
-  provider?: string
-  messageId?: string
-}): Promise<string | null> {
-  const { message, model, provider, messageId } = params
-  if (!message || !model) return null
-
-  const headers: Record<string, string> = { 'Content-Type': 'application/json' }
-  if (env.COPILOT_API_KEY) {
-    headers['x-api-key'] = env.COPILOT_API_KEY
-  }
-
-  try {
-    const response = await fetch(`${SIM_AGENT_API_URL}/api/generate-chat-title`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({ message, model, ...(provider ? { provider } : {}) }),
-    })
-
-    const payload = await response.json().catch(() => ({}))
-    if (!response.ok) {
-      logger.withMetadata({ messageId }).warn('Failed to generate chat title via copilot backend', {
-        status: response.status,
-        error: payload,
-      })
-      return null
-    }
-
-    const title = typeof payload?.title === 'string' ? payload.title.trim() : ''
-    return title || null
-  } catch (error) {
-    logger.withMetadata({ messageId }).error('Error generating chat title', error)
-    return null
-  }
-}
-
-export interface StreamingOrchestrationParams {
-  requestPayload: Record<string, unknown>
-  userId: string
-  streamId: string
-  executionId: string
-  runId: string
-  chatId?: string
-  currentChat: any
-  isNewChat: boolean
-  message: string
-  titleModel: string
-  titleProvider?: string
-  requestId: string
-  workspaceId?: string
-  orchestrateOptions: Omit<OrchestrateStreamOptions, 'onEvent'>
-  pendingChatStreamAlreadyRegistered?: boolean
-}
-
-export function createSSEStream(params: StreamingOrchestrationParams): ReadableStream {
-  const {
-    requestPayload,
-    userId,
-    streamId,
-    executionId,
-    runId,
-    chatId,
-    currentChat,
-    isNewChat,
-    message,
-    titleModel,
-    titleProvider,
-    requestId,
-    workspaceId,
-    orchestrateOptions,
-    pendingChatStreamAlreadyRegistered = false,
-  } = params
-  const messageId =
-    typeof requestPayload.messageId === 'string' ? requestPayload.messageId : streamId
-  const reqLogger = logger.withMetadata({ requestId, messageId })
-
-  let eventWriter: ReturnType<typeof createStreamEventWriter> | null = null
-  let clientDisconnected = false
-  const abortController = new AbortController()
-  const userStopController = new AbortController()
-  const clientDisconnectedController = new AbortController()
-  activeStreams.set(streamId, { abortController, userStopController })
-
-  if (chatId && !pendingChatStreamAlreadyRegistered) {
-    registerPendingChatStream(chatId, streamId)
-  }
-
-  return new ReadableStream({
-    async start(controller) {
-      const encoder = new TextEncoder()
-      const markClientDisconnected = (reason: string) => {
-        if (clientDisconnected) return
-        clientDisconnected = true
-        if (!clientDisconnectedController.signal.aborted) {
-          clientDisconnectedController.abort()
-        }
-        reqLogger.info('Client disconnected from live SSE stream', {
-          streamId,
-          runId,
-          reason,
-        })
-      }
-
-      await resetStreamBuffer(streamId)
-      await setStreamMeta(streamId, { status: 'active', userId, executionId, runId })
-      if (chatId) {
-        await createRunSegment({
-          id: runId,
-          executionId,
-          chatId,
-          userId,
-          workflowId: (requestPayload.workflowId as string | undefined) || null,
-          workspaceId,
-          streamId,
-          model: (requestPayload.model as string | undefined) || null,
-          provider: (requestPayload.provider as string | undefined) || null,
-          requestContext: { requestId },
-        }).catch((error) => {
-          reqLogger.warn('Failed to create copilot run segment', {
-            error: error instanceof Error ? error.message : String(error),
-          })
-        })
-      }
-      eventWriter = createStreamEventWriter(streamId)
-
-      let localSeq = 0
-      let abortPoller: ReturnType<typeof setInterval> | null = null
-
-      const redis = getRedisClient()
-      if (redis) {
-        abortPoller = setInterval(() => {
-          void (async () => {
-            try {
-              const shouldAbort = await redis.get(getStreamAbortKey(streamId))
-              if (shouldAbort && !abortController.signal.aborted) {
-                userStopController.abort()
-                abortController.abort()
-                await redis.del(getStreamAbortKey(streamId))
-              }
-            } catch (error) {
-              reqLogger.warn('Failed to poll distributed stream abort', {
-                streamId,
-                error: error instanceof Error ? error.message : String(error),
-              })
-            }
-          })()
-        }, STREAM_ABORT_POLL_MS)
-      }
-
-      const pushEvent = async (event: Record<string, any>) => {
-        if (!eventWriter) return
-
-        const eventId = ++localSeq
-
-        try {
-          await eventWriter.write(event)
-          if (FLUSH_EVENT_TYPES.has(event.type)) {
-            await eventWriter.flush()
-          }
-        } catch (error) {
-          reqLogger.error('Failed to persist stream event', {
-            eventType: event.type,
-            eventId,
-            error: error instanceof Error ? error.message : String(error),
-          })
-          // Keep the live SSE stream going even if durable buffering hiccups.
-        }
-
-        try {
-          if (!clientDisconnected) {
-            controller.enqueue(
-              encoder.encode(`data: ${JSON.stringify({ ...event, eventId, streamId })}\n\n`)
-            )
-          }
-        } catch {
-          markClientDisconnected('enqueue_failed')
-        }
-      }
-
-      const pushEventBestEffort = async (event: Record<string, any>) => {
-        try {
-          await pushEvent(event)
-        } catch (error) {
-          reqLogger.error('Failed to push event', {
-            eventType: event.type,
-            error: error instanceof Error ? error.message : String(error),
-          })
-        }
-      }
-
-      if (chatId) {
-        await pushEvent({ type: 'chat_id', chatId })
-      }
-
-      if (chatId && !currentChat?.title && isNewChat) {
-        requestChatTitle({ message, model: titleModel, provider: titleProvider, messageId })
-          .then(async (title) => {
-            if (title) {
-              await db.update(copilotChats).set({ title }).where(eq(copilotChats.id, chatId!))
-              await pushEvent({ type: 'title_updated', title })
-              if (workspaceId) {
-                taskPubSub?.publishStatusChanged({ workspaceId, chatId: chatId!, type: 'renamed' })
-              }
-            }
-          })
-          .catch((error) => {
-            reqLogger.error('Title generation failed', error)
-          })
-      }
-
-      const keepaliveInterval = setInterval(() => {
-        if (clientDisconnected) return
-        try {
-          controller.enqueue(encoder.encode(': keepalive\n\n'))
-        } catch {
-          markClientDisconnected('keepalive_failed')
-        }
-      }, 15_000)
-
-      try {
-        const result = await orchestrateCopilotStream(requestPayload, {
-          ...orchestrateOptions,
-          executionId,
-          runId,
-          abortSignal: abortController.signal,
-          userStopSignal: userStopController.signal,
-          clientDisconnectedSignal: clientDisconnectedController.signal,
-          onEvent: async (event) => {
-            await pushEvent(event)
-          },
-        })
-
-        if (abortController.signal.aborted) {
-          reqLogger.info('Stream aborted by explicit stop')
-          await eventWriter.close().catch(() => {})
-          await setStreamMeta(streamId, { status: 'cancelled', userId, executionId, runId })
-          await updateRunStatus(runId, 'cancelled', { completedAt: new Date() }).catch(() => {})
-          return
-        }
-
-        if (!result.success) {
-          const errorMessage =
-            result.error ||
-            result.errors?.[0] ||
-            'An unexpected error occurred while processing the response.'
-
-          if (clientDisconnected) {
-            reqLogger.info('Stream failed after client disconnect', {
-              error: errorMessage,
-            })
-          }
-
-          reqLogger.error('Orchestration returned failure', {
-            error: errorMessage,
-          })
-          await pushEventBestEffort({
-            type: 'error',
-            error: errorMessage,
-            data: {
-              displayMessage: errorMessage,
-            },
-          })
-          await eventWriter.close()
-          await setStreamMeta(streamId, {
-            status: 'error',
-            userId,
-            executionId,
-            runId,
-            error: errorMessage,
-          })
-          await updateRunStatus(runId, 'error', {
-            completedAt: new Date(),
-            error: errorMessage,
-          }).catch(() => {})
-          return
-        }
-
-        await eventWriter.close()
-        await setStreamMeta(streamId, { status: 'complete', userId, executionId, runId })
-        await updateRunStatus(runId, 'complete', { completedAt: new Date() }).catch(() => {})
-        if (clientDisconnected) {
-          reqLogger.info('Orchestration completed after client disconnect', {
-            streamId,
-            runId,
-          })
-        }
-      } catch (error) {
-        if (abortController.signal.aborted) {
-          reqLogger.info('Stream aborted by explicit stop')
-          await eventWriter.close().catch(() => {})
-          await setStreamMeta(streamId, { status: 'cancelled', userId, executionId, runId })
-          await updateRunStatus(runId, 'cancelled', { completedAt: new Date() }).catch(() => {})
-          return
-        }
-        if (clientDisconnected) {
-          reqLogger.info('Stream errored after client disconnect', {
-            error: error instanceof Error ? error.message : 'Stream error',
-          })
-        }
-        reqLogger.error('Orchestration error', error)
-        const errorMessage = error instanceof Error ? error.message : 'Stream error'
-        await pushEventBestEffort({
-          type: 'error',
-          error: errorMessage,
-          data: {
-            displayMessage: 'An unexpected error occurred while processing the response.',
-          },
-        })
-        await eventWriter.close()
-        await setStreamMeta(streamId, {
-          status: 'error',
-          userId,
-          executionId,
-          runId,
-          error: errorMessage,
-        })
-        await updateRunStatus(runId, 'error', {
-          completedAt: new Date(),
-          error: errorMessage,
-        }).catch(() => {})
-      } finally {
-        reqLogger.info('Closing live SSE stream', {
-          streamId,
-          runId,
-          clientDisconnected,
-          aborted: abortController.signal.aborted,
-        })
-        clearInterval(keepaliveInterval)
-        if (abortPoller) {
-          clearInterval(abortPoller)
-        }
-        activeStreams.delete(streamId)
-        if (chatId) {
-          if (redis) {
-            await releaseLock(getChatStreamLockKey(chatId), streamId).catch(() => false)
-          }
-          resolvePendingChatStream(chatId, streamId)
-        }
-        if (redis) {
-          await redis.del(getStreamAbortKey(streamId)).catch(() => {})
-        }
-        try {
-          controller.close()
-        } catch {
-          // Controller already closed from cancel() — safe to ignore
-        }
-      }
-    },
-    cancel() {
-      reqLogger.info('ReadableStream cancel received from client', {
-        streamId,
-        runId,
-      })
-      if (!clientDisconnected) {
-        clientDisconnected = true
-        if (!clientDisconnectedController.signal.aborted) {
-          clientDisconnectedController.abort()
-        }
-      }
-      if (eventWriter) {
-        eventWriter.flush().catch(() => {})
-      }
-    },
-  })
-}
-
-export const SSE_RESPONSE_HEADERS = {
-  ...SSE_HEADERS,
-  'Content-Encoding': 'none',
-} as const
diff --git a/apps/sim/lib/copilot/chat/display-message.test.ts b/apps/sim/lib/copilot/chat/display-message.test.ts
new file mode 100644
index 00000000000..c389cd6fadf
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/display-message.test.ts
@@ -0,0 +1,91 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import { toDisplayMessage } from './display-message'
+
+describe('display-message', () => {
+  it('maps canonical tool, subagent text, and cancelled complete blocks to display blocks', () => {
+    const display = toDisplayMessage({
+      id: 'msg-1',
+      role: 'assistant',
+      content: 'done',
+      timestamp: '2024-01-01T00:00:00.000Z',
+      requestId: 'req-1',
+      contentBlocks: [
+        {
+          type: 'tool',
+          phase: 'call',
+          toolCall: {
+            id: 'tool-1',
+            name: 'read',
+            state: 'cancelled',
+            display: { title: 'Stopped by user' },
+          },
+        },
+        {
+          type: 'text',
+          lane: 'subagent',
+          channel: 'assistant',
+          content: 'subagent output',
+        },
+        {
+          type: 'complete',
+          status: 'cancelled',
+        },
+      ],
+    })
+
+    expect(display.contentBlocks).toEqual([
+      {
+        type: 'tool_call',
+        toolCall: {
+          id: 'tool-1',
+          name: 'read',
+          status: 'cancelled',
+          displayTitle: 'Stopped by user',
+          phaseLabel: undefined,
+          params: undefined,
+          calledBy: undefined,
+          result: undefined,
+        },
+      },
+      {
+        type: 'subagent_text',
+        content: 'subagent output',
+      },
+      {
+        type: 'stopped',
+      },
+    ])
+  })
+
+  it('hides load_agent_skill blocks from display output', () => {
+    const display = toDisplayMessage({
+      id: 'msg-2',
+      role: 'assistant',
+      content: '',
+      timestamp: '2024-01-01T00:00:00.000Z',
+      contentBlocks: [
+        {
+          type: 'tool',
+          phase: 'call',
+          toolCall: {
+            id: 'tool-hidden',
+            name: 'load_agent_skill',
+            state: 'success',
+            display: { title: 'Loading skill' },
+          },
+        },
+        {
+          type: 'text',
+          channel: 'assistant',
+          content: 'visible text',
+        },
+      ],
+    })
+
+    expect(display.contentBlocks).toEqual([{ type: 'text', content: 'visible text' }])
+  })
+})
diff --git a/apps/sim/lib/copilot/chat/display-message.ts b/apps/sim/lib/copilot/chat/display-message.ts
new file mode 100644
index 00000000000..0d44097eb3d
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/display-message.ts
@@ -0,0 +1,129 @@
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
+import {
+  type ChatContextKind,
+  type ChatMessage,
+  type ChatMessageAttachment,
+  type ChatMessageContext,
+  type ContentBlock,
+  ContentBlockType,
+  type ToolCallInfo,
+  ToolCallStatus,
+} from '@/app/workspace/[workspaceId]/home/types'
+import type { PersistedContentBlock, PersistedMessage } from './persisted-message'
+
+const STATE_TO_STATUS: Record<string, ToolCallStatus> = {
+  [MothershipStreamV1ToolOutcome.success]: ToolCallStatus.success,
+  [MothershipStreamV1ToolOutcome.error]: ToolCallStatus.error,
+  [MothershipStreamV1ToolOutcome.cancelled]: ToolCallStatus.cancelled,
+  [MothershipStreamV1ToolOutcome.rejected]: ToolCallStatus.error,
+  [MothershipStreamV1ToolOutcome.skipped]: ToolCallStatus.success,
+  pending: ToolCallStatus.executing,
+  executing: ToolCallStatus.executing,
+}
+
+function toToolCallInfo(block: PersistedContentBlock): ToolCallInfo | undefined {
+  const tc = block.toolCall
+  if (!tc) return undefined
+  if (isToolHiddenInUi(tc.name)) return undefined
+  const status: ToolCallStatus = STATE_TO_STATUS[tc.state] ?? ToolCallStatus.error
+  return {
+    id: tc.id,
+    name: tc.name,
+    status,
+    displayTitle: status === ToolCallStatus.cancelled ? 'Stopped by user' : tc.display?.title,
+    phaseLabel: tc.display?.phaseLabel,
+    params: tc.params,
+    calledBy: tc.calledBy,
+    result: tc.result,
+  }
+}
+
+function toDisplayBlock(block: PersistedContentBlock): ContentBlock | undefined {
+  switch (block.type) {
+    case MothershipStreamV1EventType.text:
+      if (block.lane === 'subagent') {
+        if (block.channel === 'thinking') {
+          return { type: ContentBlockType.subagent_thinking, content: block.content }
+        }
+        return { type: ContentBlockType.subagent_text, content: block.content }
+      }
+      return { type: ContentBlockType.text, content: block.content }
+    case MothershipStreamV1EventType.tool:
+      if (!toToolCallInfo(block)) return undefined
+      return { type: ContentBlockType.tool_call, toolCall: toToolCallInfo(block) }
+    case MothershipStreamV1EventType.span:
+      if (block.lifecycle === MothershipStreamV1SpanLifecycleEvent.end) {
+        return { type: ContentBlockType.subagent_end }
+      }
+      return { type: ContentBlockType.subagent, content: block.content }
+    case MothershipStreamV1EventType.complete:
+      if (block.status === MothershipStreamV1CompletionStatus.cancelled) {
+        return { type: ContentBlockType.stopped }
+      }
+      return { type: ContentBlockType.text, content: block.content }
+    default:
+      return { type: ContentBlockType.text, content: block.content }
+  }
+}
+
+function toDisplayAttachment(f: PersistedMessage['fileAttachments']): ChatMessageAttachment[] {
+  if (!f || f.length === 0) return []
+  return f.map((a) => ({
+    id: a.id,
+    filename: a.filename,
+    media_type: a.media_type,
+    size: a.size,
+    previewUrl: a.media_type.startsWith('image/')
+      ? `/api/files/serve/${encodeURIComponent(a.key)}?context=mothership`
+      : undefined,
+  }))
+}
+
+function toDisplayContexts(
+  contexts: PersistedMessage['contexts']
+): ChatMessageContext[] | undefined {
+  if (!contexts || contexts.length === 0) return undefined
+  return contexts.map((c) => ({
+    kind: c.kind as ChatContextKind,
+    label: c.label,
+    ...(c.workflowId ? { workflowId: c.workflowId } : {}),
+    ...(c.knowledgeId ? { knowledgeId: c.knowledgeId } : {}),
+    ...(c.tableId ? { tableId: c.tableId } : {}),
+    ...(c.fileId ? { fileId: c.fileId } : {}),
+    ...(c.folderId ? { folderId: c.folderId } : {}),
+    ...(c.chatId ? { chatId: c.chatId } : {}),
+  }))
+}
+
+export function toDisplayMessage(msg: PersistedMessage): ChatMessage {
+  const display: ChatMessage = {
+    id: msg.id,
+    role: msg.role,
+    content: msg.content,
+  }
+
+  if (msg.requestId) {
+    display.requestId = msg.requestId
+  }
+
+  if (msg.contentBlocks && msg.contentBlocks.length > 0) {
+    display.contentBlocks = msg.contentBlocks
+      .map(toDisplayBlock)
+      .filter((block): block is ContentBlock => !!block)
+  }
+
+  const attachments = toDisplayAttachment(msg.fileAttachments)
+  if (attachments.length > 0) {
+    display.attachments = attachments
+  }
+
+  display.contexts = toDisplayContexts(msg.contexts)
+
+  return display
+}
diff --git a/apps/sim/lib/copilot/chat-lifecycle.ts b/apps/sim/lib/copilot/chat/lifecycle.ts
similarity index 100%
rename from apps/sim/lib/copilot/chat-lifecycle.ts
rename to apps/sim/lib/copilot/chat/lifecycle.ts
diff --git a/apps/sim/lib/copilot/chat-payload.test.ts b/apps/sim/lib/copilot/chat/payload.test.ts
similarity index 63%
rename from apps/sim/lib/copilot/chat-payload.test.ts
rename to apps/sim/lib/copilot/chat/payload.test.ts
index 817ac013cbc..4231ac64b36 100644
--- a/apps/sim/lib/copilot/chat-payload.test.ts
+++ b/apps/sim/lib/copilot/chat/payload.test.ts
@@ -3,7 +3,8 @@
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockGetHighestPrioritySubscription } = vi.hoisted(() => ({
+const { mockCreateUserToolSchema, mockGetHighestPrioritySubscription } = vi.hoisted(() => ({
+  mockCreateUserToolSchema: vi.fn(() => ({ type: 'object', properties: {} })),
   mockGetHighestPrioritySubscription: vi.fn(),
 }))
 
@@ -17,10 +18,6 @@ vi.mock('@/lib/billing/plan-helpers', () => ({
   ),
 }))
 
-vi.mock('@/lib/copilot/chat-context', () => ({
-  processFileAttachments: vi.fn(),
-}))
-
 vi.mock('@/lib/core/config/feature-flags', () => ({
   isHosted: false,
 }))
@@ -45,6 +42,12 @@ vi.mock('@/tools/registry', () => ({
       name: 'Brandfetch Search',
       description: 'Search for brands by company name',
     },
+    // Catalog marks run_workflow as client-routed / clientExecutable; registry ToolConfig has no routing fields.
+    run_workflow: {
+      id: 'run_workflow',
+      name: 'Run Workflow',
+      description: 'Run a workflow from the client',
+    },
   },
 }))
 
@@ -54,14 +57,15 @@ vi.mock('@/tools/utils', () => ({
 }))
 
 vi.mock('@/tools/params', () => ({
-  createUserToolSchema: vi.fn(() => ({ type: 'object', properties: {} })),
+  createUserToolSchema: mockCreateUserToolSchema,
 }))
 
-import { buildIntegrationToolSchemas } from '@/lib/copilot/chat-payload'
+import { buildIntegrationToolSchemas } from './payload'
 
 describe('buildIntegrationToolSchemas', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    mockCreateUserToolSchema.mockReturnValue({ type: 'object', properties: {} })
   })
 
   it('appends the email footer prompt for free users', async () => {
@@ -95,4 +99,30 @@ describe('buildIntegrationToolSchemas', () => {
     expect(gmailTool?.description).toBe('Send emails using Gmail')
     expect(brandfetchTool?.description).toBe('Search for brands by company name')
   })
+
+  it('emits executeLocally for dynamic client tools only', async () => {
+    mockGetHighestPrioritySubscription.mockResolvedValue({ plan: 'pro', status: 'active' })
+
+    const toolSchemas = await buildIntegrationToolSchemas('user-client')
+    const gmailTool = toolSchemas.find((tool) => tool.name === 'gmail_send')
+    const runTool = toolSchemas.find((tool) => tool.name === 'run_workflow')
+
+    expect(gmailTool?.executeLocally).toBe(false)
+    expect(runTool?.executeLocally).toBe(true)
+  })
+
+  it('uses copilot-facing file schemas for integration tools', async () => {
+    mockGetHighestPrioritySubscription.mockResolvedValue({ plan: 'pro', status: 'active' })
+
+    await buildIntegrationToolSchemas('user-copilot')
+
+    expect(mockCreateUserToolSchema).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'gmail_send' }),
+      { surface: 'copilot' }
+    )
+    expect(mockCreateUserToolSchema).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'brandfetch_search' }),
+      { surface: 'copilot' }
+    )
+  })
 })
diff --git a/apps/sim/lib/copilot/chat-payload.ts b/apps/sim/lib/copilot/chat/payload.ts
similarity index 51%
rename from apps/sim/lib/copilot/chat-payload.ts
rename to apps/sim/lib/copilot/chat/payload.ts
index dc82325f73f..536dd8730bd 100644
--- a/apps/sim/lib/copilot/chat-payload.ts
+++ b/apps/sim/lib/copilot/chat/payload.ts
@@ -1,17 +1,26 @@
 import { createLogger } from '@sim/logger'
 import { getHighestPrioritySubscription } from '@/lib/billing/core/subscription'
 import { isPaid } from '@/lib/billing/plan-helpers'
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { getToolEntry } from '@/lib/copilot/tool-executor/router'
+import { getCopilotToolDescription } from '@/lib/copilot/tools/descriptions'
 import { isHosted } from '@/lib/core/config/feature-flags'
 import { createMcpToolId } from '@/lib/mcp/utils'
 import { trackChatUpload } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
-import { getWorkflowById } from '@/lib/workflows/utils'
 import { tools } from '@/tools/registry'
 import { getLatestVersionTools, stripVersionSuffix } from '@/tools/utils'
 
 const logger = createLogger('CopilotChatPayload')
+const TOOL_SCHEMA_CACHE_TTL_MS = 30_000
 
-export interface BuildPayloadParams {
+type ToolSchemaCacheEntry = {
+  expiresAt: number
+  value?: ToolSchema[]
+  promise?: Promise<ToolSchema[]>
+}
+
+const toolSchemaCache = new Map<string, ToolSchemaCacheEntry>()
+
+interface BuildPayloadParams {
   message: string
   workflowId?: string
   workflowName?: string
@@ -41,6 +50,10 @@ export interface ToolSchema {
   oauth?: { required: boolean; provider: string }
 }
 
+interface BuildIntegrationToolSchemasOptions {
+  schemaSurface?: 'default' | 'copilot'
+}
+
 /**
  * Build deferred integration tool schemas from the Sim tool registry.
  * Shared by the interactive chat payload builder and the non-interactive
@@ -48,58 +61,101 @@ export interface ToolSchema {
  */
 export async function buildIntegrationToolSchemas(
   userId: string,
-  messageId?: string
+  messageId?: string,
+  options: BuildIntegrationToolSchemasOptions = { schemaSurface: 'copilot' }
 ): Promise<ToolSchema[]> {
-  const reqLogger = logger.withMetadata({ messageId })
-  const integrationTools: ToolSchema[] = []
-  try {
-    const { createUserToolSchema } = await import('@/tools/params')
-    const latestTools = getLatestVersionTools(tools)
-    let shouldAppendEmailTagline = false
+  const cacheKey = `${userId}:${options.schemaSurface ?? 'copilot'}`
+  const now = Date.now()
+  const cached = toolSchemaCache.get(cacheKey)
+  if (cached?.value && cached.expiresAt > now) {
+    return cached.value.map((tool) => ({ ...tool, input_schema: { ...tool.input_schema } }))
+  }
+  if (cached?.promise) {
+    const tools = await cached.promise
+    return tools.map((tool) => ({ ...tool, input_schema: { ...tool.input_schema } }))
+  }
 
+  const reqLogger = logger.withMetadata({ messageId })
+  const promise = (async () => {
+    const integrationTools: ToolSchema[] = []
     try {
-      const subscription = await getHighestPrioritySubscription(userId)
-      shouldAppendEmailTagline = !subscription || !isPaid(subscription.plan)
-    } catch (error) {
-      reqLogger.warn('Failed to load subscription for copilot tool descriptions', {
-        userId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
+      const { createUserToolSchema } = await import('@/tools/params')
+      const latestTools = getLatestVersionTools(tools)
+      let shouldAppendEmailTagline = false
 
-    for (const [toolId, toolConfig] of Object.entries(latestTools)) {
       try {
-        const userSchema = createUserToolSchema(toolConfig)
-        const strippedName = stripVersionSuffix(toolId)
-        integrationTools.push({
-          name: strippedName,
-          description: getCopilotToolDescription(toolConfig, {
-            isHosted,
-            fallbackName: strippedName,
-            appendEmailTagline: shouldAppendEmailTagline,
-          }),
-          input_schema: userSchema as unknown as Record<string, unknown>,
-          defer_loading: true,
-          ...(toolConfig.oauth?.required && {
-            oauth: {
-              required: true,
-              provider: toolConfig.oauth.provider,
-            },
-          }),
-        })
-      } catch (toolError) {
-        reqLogger.warn('Failed to build schema for tool, skipping', {
-          toolId,
-          error: toolError instanceof Error ? toolError.message : String(toolError),
+        const subscription = await getHighestPrioritySubscription(userId)
+        shouldAppendEmailTagline = !subscription || !isPaid(subscription.plan)
+      } catch (error) {
+        reqLogger.warn('Failed to load subscription for copilot tool descriptions', {
+          userId,
+          error: error instanceof Error ? error.message : String(error),
         })
       }
+
+      for (const [toolId, toolConfig] of Object.entries(latestTools)) {
+        try {
+          const userSchema = createUserToolSchema(toolConfig, {
+            surface: options.schemaSurface ?? 'copilot',
+          })
+          const strippedName = stripVersionSuffix(toolId)
+          const catalogEntry = getToolEntry(strippedName)
+          integrationTools.push({
+            name: strippedName,
+            description: getCopilotToolDescription(toolConfig, {
+              isHosted,
+              fallbackName: strippedName,
+              appendEmailTagline: shouldAppendEmailTagline,
+            }),
+            input_schema: userSchema as unknown as Record<string, unknown>,
+            defer_loading: true,
+            executeLocally:
+              catalogEntry?.clientExecutable === true || catalogEntry?.route === 'client',
+            ...(toolConfig.oauth?.required && {
+              oauth: {
+                required: true,
+                provider: toolConfig.oauth.provider,
+              },
+            }),
+          })
+        } catch (toolError) {
+          logger.warn(
+            messageId
+              ? `Failed to build schema for tool, skipping [messageId:${messageId}]`
+              : 'Failed to build schema for tool, skipping',
+            {
+              toolId,
+              error: toolError instanceof Error ? toolError.message : String(toolError),
+            }
+          )
+        }
+      }
+    } catch (error) {
+      logger.warn(
+        messageId
+          ? `Failed to build tool schemas [messageId:${messageId}]`
+          : 'Failed to build tool schemas',
+        {
+          error: error instanceof Error ? error.message : String(error),
+        }
+      )
     }
-  } catch (error) {
-    reqLogger.warn('Failed to build tool schemas', {
-      error: error instanceof Error ? error.message : String(error),
+
+    toolSchemaCache.set(cacheKey, {
+      value: integrationTools,
+      expiresAt: Date.now() + TOOL_SCHEMA_CACHE_TTL_MS,
     })
-  }
-  return integrationTools
+
+    return integrationTools
+  })()
+
+  toolSchemaCache.set(cacheKey, {
+    expiresAt: now + TOOL_SCHEMA_CACHE_TTL_MS,
+    promise,
+  })
+
+  const integrationTools = await promise
+  return integrationTools.map((tool) => ({ ...tool, input_schema: { ...tool.input_schema } }))
 }
 
 /**
@@ -178,31 +234,40 @@ export async function buildCopilotRequestPayload(
   const payloadLogger = logger.withMetadata({ messageId: userMessageId })
 
   if (effectiveMode === 'build') {
-    integrationTools = await buildIntegrationToolSchemas(userId, userMessageId)
+    integrationTools = await buildIntegrationToolSchemas(userId, userMessageId, {
+      schemaSurface: 'copilot',
+    })
 
     // Discover MCP tools from workspace servers and include as deferred tools
-    if (workflowId) {
+    if (params.workspaceId) {
       try {
-        const wf = await getWorkflowById(workflowId)
-        if (wf?.workspaceId) {
-          const { mcpService } = await import('@/lib/mcp/service')
-          const mcpTools = await mcpService.discoverTools(userId, wf.workspaceId)
-          for (const mcpTool of mcpTools) {
-            integrationTools.push({
-              name: createMcpToolId(mcpTool.serverId, mcpTool.name),
-              description:
-                mcpTool.description || `MCP tool: ${mcpTool.name} (${mcpTool.serverName})`,
-              input_schema: mcpTool.inputSchema as unknown as Record<string, unknown>,
-            })
-          }
-          if (mcpTools.length > 0) {
-            payloadLogger.info('Added MCP tools to copilot payload', { count: mcpTools.length })
-          }
+        const { mcpService } = await import('@/lib/mcp/service')
+        const mcpTools = await mcpService.discoverTools(userId, params.workspaceId)
+        for (const mcpTool of mcpTools) {
+          integrationTools.push({
+            name: createMcpToolId(mcpTool.serverId, mcpTool.name),
+            description: mcpTool.description || `MCP tool: ${mcpTool.name} (${mcpTool.serverName})`,
+            input_schema: mcpTool.inputSchema as unknown as Record<string, unknown>,
+            executeLocally: false,
+          })
+        }
+        if (mcpTools.length > 0) {
+          logger.error(
+            userMessageId
+              ? `Added MCP tools to copilot payload [messageId:${userMessageId}]`
+              : 'Added MCP tools to copilot payload',
+            { count: mcpTools.length }
+          )
         }
       } catch (error) {
-        payloadLogger.warn('Failed to discover MCP tools for copilot', {
-          error: error instanceof Error ? error.message : String(error),
-        })
+        logger.warn(
+          userMessageId
+            ? `Failed to discover MCP tools for copilot [messageId:${userMessageId}]`
+            : 'Failed to discover MCP tools for copilot',
+          {
+            error: error instanceof Error ? error.message : String(error),
+          }
+        )
       }
     }
   }
diff --git a/apps/sim/lib/copilot/chat/persisted-message.test.ts b/apps/sim/lib/copilot/chat/persisted-message.test.ts
new file mode 100644
index 00000000000..b5839351d3d
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/persisted-message.test.ts
@@ -0,0 +1,139 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+import {
+  buildPersistedAssistantMessage,
+  buildPersistedUserMessage,
+  normalizeMessage,
+} from './persisted-message'
+
+describe('persisted-message', () => {
+  it('round-trips canonical tool blocks through normalizeMessage', () => {
+    const result: OrchestratorResult = {
+      success: true,
+      content: 'done',
+      requestId: 'req-1',
+      contentBlocks: [
+        {
+          type: 'tool_call',
+          timestamp: Date.now(),
+          calledBy: 'workflow',
+          toolCall: {
+            id: 'tool-1',
+            name: 'read',
+            status: 'success',
+            displayTitle: 'Reading foo.txt',
+            phaseLabel: 'Workspace',
+            params: { path: 'foo.txt' },
+            result: { success: true, output: { ok: true } },
+          },
+        },
+      ],
+      toolCalls: [],
+    }
+
+    const persisted = buildPersistedAssistantMessage(result)
+    const normalized = normalizeMessage(persisted as unknown as Record<string, unknown>)
+
+    expect(normalized.contentBlocks).toEqual([
+      {
+        type: 'tool',
+        phase: 'call',
+        toolCall: {
+          id: 'tool-1',
+          name: 'read',
+          state: 'success',
+          display: { title: 'Reading foo.txt', phaseLabel: 'Workspace' },
+          params: { path: 'foo.txt' },
+          result: { success: true, output: { ok: true } },
+          calledBy: 'workflow',
+        },
+      },
+      {
+        type: 'text',
+        channel: 'assistant',
+        content: 'done',
+      },
+    ])
+  })
+
+  it('prefers an explicit persisted request ID override', () => {
+    const result: OrchestratorResult = {
+      success: true,
+      content: 'done',
+      requestId: 'go-trace-1',
+      contentBlocks: [],
+      toolCalls: [],
+    }
+
+    const persisted = buildPersistedAssistantMessage(result, 'sim-request-1')
+
+    expect(persisted.requestId).toBe('sim-request-1')
+  })
+
+  it('normalizes legacy tool_call and top-level toolCalls shapes', () => {
+    const normalized = normalizeMessage({
+      id: 'msg-1',
+      role: 'assistant',
+      content: 'hello',
+      timestamp: '2024-01-01T00:00:00.000Z',
+      contentBlocks: [
+        {
+          type: 'tool_call',
+          toolCall: {
+            id: 'tool-1',
+            name: 'read',
+            state: 'cancelled',
+            display: { title: 'Stopped by user', phaseLabel: 'Workspace' },
+          },
+        },
+      ],
+      toolCalls: [
+        {
+          id: 'tool-2',
+          name: 'glob',
+          status: 'success',
+          result: { matches: [] },
+        },
+      ],
+    })
+
+    expect(normalized.contentBlocks).toEqual([
+      {
+        type: 'tool',
+        phase: 'call',
+        toolCall: {
+          id: 'tool-1',
+          name: 'read',
+          state: 'cancelled',
+          display: { title: 'Stopped by user', phaseLabel: 'Workspace' },
+        },
+      },
+      {
+        type: 'text',
+        channel: 'assistant',
+        content: 'hello',
+      },
+    ])
+  })
+
+  it('builds normalized user messages with stripped optional empties', () => {
+    const msg = buildPersistedUserMessage({
+      id: 'user-1',
+      content: 'hello',
+      fileAttachments: [],
+      contexts: [],
+    })
+
+    expect(msg).toMatchObject({
+      id: 'user-1',
+      role: 'user',
+      content: 'hello',
+    })
+    expect(msg.fileAttachments).toBeUndefined()
+    expect(msg.contexts).toBeUndefined()
+  })
+})
diff --git a/apps/sim/lib/copilot/chat/persisted-message.ts b/apps/sim/lib/copilot/chat/persisted-message.ts
new file mode 100644
index 00000000000..b178c2854cb
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/persisted-message.ts
@@ -0,0 +1,509 @@
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1SpanLifecycleEvent,
+  MothershipStreamV1SpanPayloadKind,
+  type MothershipStreamV1StreamScope,
+  MothershipStreamV1TextChannel,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type {
+  ContentBlock,
+  LocalToolCallStatus,
+  OrchestratorResult,
+} from '@/lib/copilot/request/types'
+
+export type PersistedToolState = LocalToolCallStatus | MothershipStreamV1ToolOutcome
+
+export interface PersistedToolCall {
+  id: string
+  name: string
+  state: PersistedToolState
+  params?: Record<string, unknown>
+  result?: { success: boolean; output?: unknown; error?: string }
+  error?: string
+  calledBy?: string
+  durationMs?: number
+  display?: { title?: string; phaseLabel?: string }
+}
+
+export interface PersistedContentBlock {
+  type: MothershipStreamV1EventType
+  lane?: MothershipStreamV1StreamScope['lane']
+  channel?: MothershipStreamV1TextChannel
+  phase?: MothershipStreamV1ToolPhase
+  kind?: MothershipStreamV1SpanPayloadKind
+  lifecycle?: MothershipStreamV1SpanLifecycleEvent
+  status?: MothershipStreamV1CompletionStatus
+  content?: string
+  toolCall?: PersistedToolCall
+}
+
+export interface PersistedFileAttachment {
+  id: string
+  key: string
+  filename: string
+  media_type: string
+  size: number
+}
+
+export interface PersistedMessageContext {
+  kind: string
+  label: string
+  workflowId?: string
+  knowledgeId?: string
+  tableId?: string
+  fileId?: string
+  folderId?: string
+  chatId?: string
+}
+
+export interface PersistedMessage {
+  id: string
+  role: 'user' | 'assistant'
+  content: string
+  timestamp: string
+  requestId?: string
+  contentBlocks?: PersistedContentBlock[]
+  fileAttachments?: PersistedFileAttachment[]
+  contexts?: PersistedMessageContext[]
+}
+
+// ---------------------------------------------------------------------------
+// Write: OrchestratorResult → PersistedMessage
+// ---------------------------------------------------------------------------
+
+function resolveToolState(block: ContentBlock): PersistedToolState {
+  const tc = block.toolCall
+  if (!tc) return 'pending'
+  if (tc.result?.success !== undefined) {
+    return tc.result.success
+      ? MothershipStreamV1ToolOutcome.success
+      : MothershipStreamV1ToolOutcome.error
+  }
+  return tc.status as PersistedToolState
+}
+
+function mapContentBlock(block: ContentBlock): PersistedContentBlock {
+  switch (block.type) {
+    case 'text':
+      return {
+        type: MothershipStreamV1EventType.text,
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: block.content,
+      }
+    case 'thinking':
+      return {
+        type: MothershipStreamV1EventType.text,
+        channel: MothershipStreamV1TextChannel.thinking,
+        content: block.content,
+      }
+    case 'subagent':
+      return {
+        type: MothershipStreamV1EventType.span,
+        kind: MothershipStreamV1SpanPayloadKind.subagent,
+        lifecycle: MothershipStreamV1SpanLifecycleEvent.start,
+        content: block.content,
+      }
+    case 'subagent_text':
+      return {
+        type: MothershipStreamV1EventType.text,
+        lane: 'subagent',
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: block.content,
+      }
+    case 'subagent_thinking':
+      return {
+        type: MothershipStreamV1EventType.text,
+        lane: 'subagent',
+        channel: MothershipStreamV1TextChannel.thinking,
+        content: block.content,
+      }
+    case 'tool_call': {
+      if (!block.toolCall) {
+        return {
+          type: MothershipStreamV1EventType.tool,
+          phase: MothershipStreamV1ToolPhase.call,
+          content: block.content,
+        }
+      }
+      const state = resolveToolState(block)
+      const isSubagentTool = !!block.calledBy
+      const isNonTerminal =
+        state === MothershipStreamV1ToolOutcome.cancelled ||
+        state === 'pending' ||
+        state === 'executing'
+
+      const toolCall: PersistedToolCall = {
+        id: block.toolCall.id,
+        name: block.toolCall.name,
+        state,
+        ...(isSubagentTool && isNonTerminal ? {} : { result: block.toolCall.result }),
+        ...(isSubagentTool && isNonTerminal
+          ? {}
+          : block.toolCall.params
+            ? { params: block.toolCall.params }
+            : {}),
+        ...(block.calledBy ? { calledBy: block.calledBy } : {}),
+        ...(block.toolCall.displayTitle || block.toolCall.phaseLabel
+          ? {
+              display: {
+                ...(block.toolCall.displayTitle ? { title: block.toolCall.displayTitle } : {}),
+                ...(block.toolCall.phaseLabel ? { phaseLabel: block.toolCall.phaseLabel } : {}),
+              },
+            }
+          : {}),
+      }
+
+      return {
+        type: MothershipStreamV1EventType.tool,
+        phase: MothershipStreamV1ToolPhase.call,
+        toolCall,
+      }
+    }
+    default:
+      return { type: MothershipStreamV1EventType.text, content: block.content }
+  }
+}
+
+export function buildPersistedAssistantMessage(
+  result: OrchestratorResult,
+  requestId?: string
+): PersistedMessage {
+  const message: PersistedMessage = {
+    id: crypto.randomUUID(),
+    role: 'assistant',
+    content: result.content,
+    timestamp: new Date().toISOString(),
+  }
+
+  if (requestId || result.requestId) {
+    message.requestId = requestId || result.requestId
+  }
+
+  if (result.contentBlocks.length > 0) {
+    message.contentBlocks = result.contentBlocks.map(mapContentBlock)
+  }
+
+  return message
+}
+
+export interface UserMessageParams {
+  id: string
+  content: string
+  fileAttachments?: PersistedFileAttachment[]
+  contexts?: PersistedMessageContext[]
+}
+
+export function buildPersistedUserMessage(params: UserMessageParams): PersistedMessage {
+  const message: PersistedMessage = {
+    id: params.id,
+    role: 'user',
+    content: params.content,
+    timestamp: new Date().toISOString(),
+  }
+
+  if (params.fileAttachments && params.fileAttachments.length > 0) {
+    message.fileAttachments = params.fileAttachments
+  }
+
+  if (params.contexts && params.contexts.length > 0) {
+    message.contexts = params.contexts.map((c) => ({
+      kind: c.kind,
+      label: c.label,
+      ...(c.workflowId ? { workflowId: c.workflowId } : {}),
+      ...(c.knowledgeId ? { knowledgeId: c.knowledgeId } : {}),
+      ...(c.tableId ? { tableId: c.tableId } : {}),
+      ...(c.fileId ? { fileId: c.fileId } : {}),
+      ...(c.folderId ? { folderId: c.folderId } : {}),
+      ...(c.chatId ? { chatId: c.chatId } : {}),
+    }))
+  }
+
+  return message
+}
+
+// ---------------------------------------------------------------------------
+// Read: raw JSONB → PersistedMessage
+// Handles both canonical (type: 'tool', 'text', 'span', 'complete') and
+// legacy (type: 'tool_call', 'thinking', 'subagent', 'stopped') blocks.
+// ---------------------------------------------------------------------------
+
+const CANONICAL_BLOCK_TYPES: Set<string> = new Set(Object.values(MothershipStreamV1EventType))
+
+interface RawBlock {
+  type: string
+  lane?: string
+  content?: string
+  /** Go persists text blocks with key "text" instead of "content" */
+  text?: string
+  channel?: string
+  phase?: string
+  kind?: string
+  lifecycle?: string
+  status?: string
+  toolCall?: {
+    id?: string
+    name?: string
+    state?: string
+    params?: Record<string, unknown>
+    result?: { success: boolean; output?: unknown; error?: string }
+    display?: { text?: string; title?: string; phaseLabel?: string }
+    calledBy?: string
+    durationMs?: number
+    error?: string
+  } | null
+}
+
+interface LegacyToolCall {
+  id: string
+  name: string
+  status: string
+  params?: Record<string, unknown>
+  result?: unknown
+  error?: string
+  durationMs?: number
+}
+
+const OUTCOME_NORMALIZATION: Record<string, PersistedToolState> = {
+  [MothershipStreamV1ToolOutcome.success]: MothershipStreamV1ToolOutcome.success,
+  [MothershipStreamV1ToolOutcome.error]: MothershipStreamV1ToolOutcome.error,
+  [MothershipStreamV1ToolOutcome.cancelled]: MothershipStreamV1ToolOutcome.cancelled,
+  [MothershipStreamV1ToolOutcome.skipped]: MothershipStreamV1ToolOutcome.skipped,
+  [MothershipStreamV1ToolOutcome.rejected]: MothershipStreamV1ToolOutcome.rejected,
+  pending: 'pending',
+  executing: 'executing',
+}
+
+function normalizeToolState(state: string | undefined): PersistedToolState {
+  if (!state) return 'pending'
+  return OUTCOME_NORMALIZATION[state] ?? MothershipStreamV1ToolOutcome.error
+}
+
+function isCanonicalBlock(block: RawBlock): boolean {
+  return CANONICAL_BLOCK_TYPES.has(block.type)
+}
+
+function normalizeCanonicalBlock(block: RawBlock): PersistedContentBlock {
+  const result: PersistedContentBlock = {
+    type: block.type as MothershipStreamV1EventType,
+  }
+  if (block.lane === 'subagent') {
+    result.lane = block.lane
+  }
+  const blockContent = block.content ?? block.text
+  if (blockContent !== undefined) result.content = blockContent
+  if (block.channel) result.channel = block.channel as MothershipStreamV1TextChannel
+  if (block.phase) result.phase = block.phase as MothershipStreamV1ToolPhase
+  if (block.kind) result.kind = block.kind as MothershipStreamV1SpanPayloadKind
+  if (block.lifecycle) result.lifecycle = block.lifecycle as MothershipStreamV1SpanLifecycleEvent
+  if (block.status) result.status = block.status as MothershipStreamV1CompletionStatus
+  if (block.toolCall) {
+    result.toolCall = {
+      id: block.toolCall.id ?? '',
+      name: block.toolCall.name ?? '',
+      state: normalizeToolState(block.toolCall.state),
+      ...(block.toolCall.params ? { params: block.toolCall.params } : {}),
+      ...(block.toolCall.result ? { result: block.toolCall.result } : {}),
+      ...(block.toolCall.calledBy ? { calledBy: block.toolCall.calledBy } : {}),
+      ...(block.toolCall.error ? { error: block.toolCall.error } : {}),
+      ...(block.toolCall.durationMs ? { durationMs: block.toolCall.durationMs } : {}),
+      ...(block.toolCall.display
+        ? {
+            display: {
+              title: block.toolCall.display.title ?? block.toolCall.display.text,
+              phaseLabel: block.toolCall.display.phaseLabel,
+            },
+          }
+        : {}),
+    }
+  }
+  return result
+}
+
+function normalizeLegacyBlock(block: RawBlock): PersistedContentBlock {
+  if (block.type === 'tool_call' && block.toolCall) {
+    return {
+      type: MothershipStreamV1EventType.tool,
+      phase: MothershipStreamV1ToolPhase.call,
+      toolCall: {
+        id: block.toolCall.id ?? '',
+        name: block.toolCall.name ?? '',
+        state: normalizeToolState(block.toolCall.state),
+        ...(block.toolCall.params ? { params: block.toolCall.params } : {}),
+        ...(block.toolCall.result ? { result: block.toolCall.result } : {}),
+        ...(block.toolCall.calledBy ? { calledBy: block.toolCall.calledBy } : {}),
+        ...(block.toolCall.display
+          ? {
+              display: {
+                title: block.toolCall.display.title ?? block.toolCall.display.text,
+                phaseLabel: block.toolCall.display.phaseLabel,
+              },
+            }
+          : {}),
+      },
+    }
+  }
+
+  if (block.type === 'thinking') {
+    return {
+      type: MothershipStreamV1EventType.text,
+      channel: MothershipStreamV1TextChannel.thinking,
+      content: block.content,
+    }
+  }
+
+  if (block.type === 'subagent' || block.type === 'subagent_text') {
+    if (block.type === 'subagent_text') {
+      return {
+        type: MothershipStreamV1EventType.text,
+        lane: 'subagent',
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: block.content,
+      }
+    }
+    return {
+      type: MothershipStreamV1EventType.span,
+      kind: MothershipStreamV1SpanPayloadKind.subagent,
+      lifecycle: MothershipStreamV1SpanLifecycleEvent.start,
+      content: block.content,
+    }
+  }
+
+  if (block.type === 'subagent_thinking') {
+    return {
+      type: MothershipStreamV1EventType.text,
+      lane: 'subagent',
+      channel: MothershipStreamV1TextChannel.thinking,
+      content: block.content,
+    }
+  }
+
+  if (block.type === 'subagent_end') {
+    return {
+      type: MothershipStreamV1EventType.span,
+      kind: MothershipStreamV1SpanPayloadKind.subagent,
+      lifecycle: MothershipStreamV1SpanLifecycleEvent.end,
+    }
+  }
+
+  if (block.type === 'stopped') {
+    return {
+      type: MothershipStreamV1EventType.complete,
+      status: MothershipStreamV1CompletionStatus.cancelled,
+    }
+  }
+
+  return {
+    type: MothershipStreamV1EventType.text,
+    channel: MothershipStreamV1TextChannel.assistant,
+    content: block.content ?? block.text,
+  }
+}
+
+function normalizeBlock(block: RawBlock): PersistedContentBlock {
+  return isCanonicalBlock(block) ? normalizeCanonicalBlock(block) : normalizeLegacyBlock(block)
+}
+
+function normalizeLegacyToolCall(tc: LegacyToolCall): PersistedContentBlock {
+  const state = normalizeToolState(tc.status)
+  return {
+    type: MothershipStreamV1EventType.tool,
+    phase: MothershipStreamV1ToolPhase.call,
+    toolCall: {
+      id: tc.id,
+      name: tc.name,
+      state,
+      ...(tc.params ? { params: tc.params } : {}),
+      ...(tc.result != null
+        ? {
+            result: {
+              success: tc.status === MothershipStreamV1ToolOutcome.success,
+              output: tc.result,
+              ...(tc.error ? { error: tc.error } : {}),
+            },
+          }
+        : {}),
+      ...(tc.durationMs ? { durationMs: tc.durationMs } : {}),
+    },
+  }
+}
+
+function blocksContainTools(blocks: RawBlock[]): boolean {
+  return blocks.some((b) => b.type === 'tool_call' || b.type === MothershipStreamV1EventType.tool)
+}
+
+function normalizeBlocks(rawBlocks: RawBlock[], messageContent: string): PersistedContentBlock[] {
+  const blocks = rawBlocks.map(normalizeBlock)
+  const hasAssistantText = blocks.some(
+    (b) =>
+      b.type === MothershipStreamV1EventType.text &&
+      b.channel !== MothershipStreamV1TextChannel.thinking &&
+      b.content?.trim()
+  )
+  if (!hasAssistantText && messageContent.trim()) {
+    blocks.push({
+      type: MothershipStreamV1EventType.text,
+      channel: MothershipStreamV1TextChannel.assistant,
+      content: messageContent,
+    })
+  }
+  return blocks
+}
+
+export function normalizeMessage(raw: Record<string, unknown>): PersistedMessage {
+  const msg: PersistedMessage = {
+    id: (raw.id as string) ?? crypto.randomUUID(),
+    role: (raw.role as 'user' | 'assistant') ?? 'assistant',
+    content: (raw.content as string) ?? '',
+    timestamp: (raw.timestamp as string) ?? new Date().toISOString(),
+  }
+
+  if (raw.requestId && typeof raw.requestId === 'string') {
+    msg.requestId = raw.requestId
+  }
+
+  const rawBlocks = raw.contentBlocks as RawBlock[] | undefined
+  const rawToolCalls = raw.toolCalls as LegacyToolCall[] | undefined
+  const hasBlocks = Array.isArray(rawBlocks) && rawBlocks.length > 0
+  const hasToolCalls = Array.isArray(rawToolCalls) && rawToolCalls.length > 0
+
+  if (hasBlocks) {
+    msg.contentBlocks = normalizeBlocks(rawBlocks!, msg.content)
+    const contentBlocksAlreadyContainTools = blocksContainTools(rawBlocks!)
+    if (hasToolCalls && !contentBlocksAlreadyContainTools) {
+      msg.contentBlocks.push(...rawToolCalls!.map(normalizeLegacyToolCall))
+    }
+  } else if (hasToolCalls) {
+    msg.contentBlocks = rawToolCalls!.map(normalizeLegacyToolCall)
+    if (msg.content.trim()) {
+      msg.contentBlocks.push({
+        type: MothershipStreamV1EventType.text,
+        channel: MothershipStreamV1TextChannel.assistant,
+        content: msg.content,
+      })
+    }
+  }
+
+  const rawAttachments = raw.fileAttachments as PersistedFileAttachment[] | undefined
+  if (Array.isArray(rawAttachments) && rawAttachments.length > 0) {
+    msg.fileAttachments = rawAttachments
+  }
+
+  const rawContexts = raw.contexts as PersistedMessageContext[] | undefined
+  if (Array.isArray(rawContexts) && rawContexts.length > 0) {
+    msg.contexts = rawContexts.map((c) => ({
+      kind: c.kind,
+      label: c.label,
+      ...(c.workflowId ? { workflowId: c.workflowId } : {}),
+      ...(c.knowledgeId ? { knowledgeId: c.knowledgeId } : {}),
+      ...(c.tableId ? { tableId: c.tableId } : {}),
+      ...(c.fileId ? { fileId: c.fileId } : {}),
+      ...(c.folderId ? { folderId: c.folderId } : {}),
+      ...(c.chatId ? { chatId: c.chatId } : {}),
+    }))
+  }
+
+  return msg
+}
diff --git a/apps/sim/lib/copilot/chat/post.test.ts b/apps/sim/lib/copilot/chat/post.test.ts
new file mode 100644
index 00000000000..4e819bcbd2d
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/post.test.ts
@@ -0,0 +1,227 @@
+/**
+ * @vitest-environment node
+ */
+
+import { NextRequest } from 'next/server'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  getSession,
+  resolveWorkflowIdForUser,
+  getWorkflowById,
+  getUserEntityPermissions,
+  getEffectiveDecryptedEnv,
+  generateWorkspaceContext,
+  processContextsServer,
+  resolveActiveResourceContext,
+  buildCopilotRequestPayload,
+  createSSEStream,
+  acquirePendingChatStream,
+  getPendingChatStreamId,
+  releasePendingChatStream,
+  resolveOrCreateChat,
+} = vi.hoisted(() => ({
+  getSession: vi.fn(),
+  resolveWorkflowIdForUser: vi.fn(),
+  getWorkflowById: vi.fn(),
+  getUserEntityPermissions: vi.fn(),
+  getEffectiveDecryptedEnv: vi.fn(),
+  generateWorkspaceContext: vi.fn(),
+  processContextsServer: vi.fn(),
+  resolveActiveResourceContext: vi.fn(),
+  buildCopilotRequestPayload: vi.fn(),
+  createSSEStream: vi.fn(),
+  acquirePendingChatStream: vi.fn(),
+  getPendingChatStreamId: vi.fn(),
+  releasePendingChatStream: vi.fn(),
+  resolveOrCreateChat: vi.fn(),
+}))
+
+vi.mock('@/lib/auth', () => ({
+  getSession,
+}))
+
+vi.mock('@/lib/workflows/utils', () => ({
+  resolveWorkflowIdForUser,
+  getWorkflowById,
+}))
+
+vi.mock('@/lib/workspaces/permissions/utils', () => ({
+  getUserEntityPermissions,
+}))
+
+vi.mock('@/lib/environment/utils', () => ({
+  getEffectiveDecryptedEnv,
+}))
+
+vi.mock('@/lib/copilot/chat/workspace-context', () => ({
+  generateWorkspaceContext,
+}))
+
+vi.mock('@/lib/copilot/chat/process-contents', () => ({
+  processContextsServer,
+  resolveActiveResourceContext,
+}))
+
+vi.mock('@/lib/copilot/chat/payload', () => ({
+  buildCopilotRequestPayload,
+}))
+
+vi.mock('@/lib/copilot/request/lifecycle/start', () => ({
+  createSSEStream,
+  SSE_RESPONSE_HEADERS: { 'Content-Type': 'text/event-stream' },
+}))
+
+vi.mock('@/lib/copilot/request/session', () => ({
+  acquirePendingChatStream,
+  getPendingChatStreamId,
+  releasePendingChatStream,
+}))
+
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
+  resolveOrCreateChat,
+}))
+
+vi.mock('@/lib/copilot/tasks', () => ({
+  taskPubSub: {
+    publishStatusChanged: vi.fn(),
+  },
+}))
+
+vi.mock('@sim/db', () => ({
+  db: {
+    update: vi.fn(() => ({
+      set: vi.fn(() => ({
+        where: vi.fn(() => ({
+          returning: vi.fn().mockResolvedValue([]),
+        })),
+      })),
+    })),
+  },
+}))
+
+vi.mock('@sim/db/schema', () => ({
+  copilotChats: {
+    id: 'id',
+    messages: 'messages',
+    conversationId: 'conversationId',
+    updatedAt: 'updatedAt',
+  },
+}))
+
+vi.mock('drizzle-orm', () => ({
+  eq: vi.fn(() => ({})),
+  sql: (strings: TemplateStringsArray, ...values: unknown[]) => ({ strings, values }),
+}))
+
+import { handleUnifiedChatPost } from './post'
+
+describe('handleUnifiedChatPost', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    getSession.mockResolvedValue({ user: { id: 'user-1' } })
+    resolveWorkflowIdForUser.mockResolvedValue({
+      workflowId: 'wf-1',
+      workflowName: 'Workflow One',
+    })
+    getWorkflowById.mockResolvedValue({ workspaceId: 'ws-1' })
+    getUserEntityPermissions.mockResolvedValue('write')
+    getEffectiveDecryptedEnv.mockResolvedValue({ API_KEY: 'secret' })
+    generateWorkspaceContext.mockResolvedValue('workspace context')
+    processContextsServer.mockResolvedValue([])
+    resolveActiveResourceContext.mockResolvedValue(null)
+    buildCopilotRequestPayload.mockImplementation(async (params: Record<string, unknown>) => params)
+    createSSEStream.mockReturnValue(new ReadableStream())
+    acquirePendingChatStream.mockResolvedValue(true)
+    getPendingChatStreamId.mockResolvedValue(null)
+    releasePendingChatStream.mockResolvedValue(undefined)
+    resolveOrCreateChat.mockResolvedValue({
+      chatId: 'chat-1',
+      chat: { id: 'chat-1' },
+      conversationHistory: [],
+      isNew: true,
+    })
+  })
+
+  it('routes workflow-attached chat requests through the copilot backend path', async () => {
+    const response = await handleUnifiedChatPost(
+      new NextRequest('http://localhost/api/copilot/chat', {
+        method: 'POST',
+        body: JSON.stringify({
+          message: 'Hello',
+          workflowId: 'wf-1',
+          workspaceId: 'ws-1',
+        }),
+      })
+    )
+
+    expect(response.status).toBe(200)
+    expect(createSSEStream).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceId: 'ws-1',
+        orchestrateOptions: expect.objectContaining({
+          workflowId: 'wf-1',
+          goRoute: '/api/copilot',
+          executionContext: expect.objectContaining({
+            userId: 'user-1',
+            workflowId: 'wf-1',
+            workspaceId: 'ws-1',
+            requestMode: 'agent',
+          }),
+        }),
+      })
+    )
+  })
+
+  it('routes workspace chat requests through the mothership backend path', async () => {
+    const response = await handleUnifiedChatPost(
+      new NextRequest('http://localhost/api/copilot/chat', {
+        method: 'POST',
+        body: JSON.stringify({
+          message: 'Hello',
+          workspaceId: 'ws-1',
+        }),
+      })
+    )
+
+    expect(response.status).toBe(200)
+    expect(buildCopilotRequestPayload).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceId: 'ws-1',
+        workspaceContext: 'workspace context',
+      }),
+      { selectedModel: '' }
+    )
+    expect(createSSEStream).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceId: 'ws-1',
+        orchestrateOptions: expect.objectContaining({
+          workspaceId: 'ws-1',
+          goRoute: '/api/mothership',
+          executionContext: expect.objectContaining({
+            userId: 'user-1',
+            workflowId: '',
+            workspaceId: 'ws-1',
+            requestMode: 'agent',
+          }),
+        }),
+      })
+    )
+  })
+
+  it('rejects requests that have neither workflow nor workspace attachment', async () => {
+    const response = await handleUnifiedChatPost(
+      new NextRequest('http://localhost/api/copilot/chat', {
+        method: 'POST',
+        body: JSON.stringify({
+          message: 'Hello',
+        }),
+      })
+    )
+
+    expect(response.status).toBe(400)
+    await expect(response.json()).resolves.toMatchObject({
+      error: 'workspaceId is required when workflowId is not provided',
+    })
+  })
+})
diff --git a/apps/sim/lib/copilot/chat/post.ts b/apps/sim/lib/copilot/chat/post.ts
new file mode 100644
index 00000000000..f7563b4a451
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/post.ts
@@ -0,0 +1,765 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { getSession } from '@/lib/auth'
+import { type ChatLoadResult, resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
+import { buildCopilotRequestPayload } from '@/lib/copilot/chat/payload'
+import {
+  buildPersistedAssistantMessage,
+  buildPersistedUserMessage,
+} from '@/lib/copilot/chat/persisted-message'
+import {
+  processContextsServer,
+  resolveActiveResourceContext,
+} from '@/lib/copilot/chat/process-contents'
+import { finalizeAssistantTurn } from '@/lib/copilot/chat/terminal-state'
+import { generateWorkspaceContext } from '@/lib/copilot/chat/workspace-context'
+import { COPILOT_REQUEST_MODES } from '@/lib/copilot/constants'
+import {
+  createBadRequestResponse,
+  createRequestTracker,
+  createUnauthorizedResponse,
+} from '@/lib/copilot/request/http'
+import { createSSEStream, SSE_RESPONSE_HEADERS } from '@/lib/copilot/request/lifecycle/start'
+import {
+  acquirePendingChatStream,
+  getPendingChatStreamId,
+  releasePendingChatStream,
+} from '@/lib/copilot/request/session'
+import type { ExecutionContext, OrchestratorResult } from '@/lib/copilot/request/types'
+import { persistChatResources } from '@/lib/copilot/resources/persistence'
+import { taskPubSub } from '@/lib/copilot/tasks'
+import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+import { getWorkflowById, resolveWorkflowIdForUser } from '@/lib/workflows/utils'
+import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
+import type { ChatContext } from '@/stores/panel'
+
+export const maxDuration = 3600
+
+const logger = createLogger('UnifiedChatAPI')
+const DEFAULT_MODEL = 'claude-opus-4-6'
+
+const FileAttachmentSchema = z.object({
+  id: z.string(),
+  key: z.string(),
+  filename: z.string(),
+  media_type: z.string(),
+  size: z.number(),
+})
+
+const ResourceAttachmentSchema = z.object({
+  type: z.enum(['workflow', 'table', 'file', 'knowledgebase', 'folder']),
+  id: z.string().min(1),
+  title: z.string().optional(),
+  active: z.boolean().optional(),
+})
+
+const GENERIC_RESOURCE_TITLE: Record<z.infer<typeof ResourceAttachmentSchema>['type'], string> = {
+  workflow: 'Workflow',
+  table: 'Table',
+  file: 'File',
+  knowledgebase: 'Knowledge Base',
+  folder: 'Folder',
+}
+
+const ChatContextSchema = z.object({
+  kind: z.enum([
+    'past_chat',
+    'workflow',
+    'current_workflow',
+    'blocks',
+    'logs',
+    'workflow_block',
+    'knowledge',
+    'templates',
+    'docs',
+    'table',
+    'file',
+    'folder',
+  ]),
+  label: z.string(),
+  chatId: z.string().optional(),
+  workflowId: z.string().optional(),
+  knowledgeId: z.string().optional(),
+  blockId: z.string().optional(),
+  blockIds: z.array(z.string()).optional(),
+  templateId: z.string().optional(),
+  executionId: z.string().optional(),
+  tableId: z.string().optional(),
+  fileId: z.string().optional(),
+  folderId: z.string().optional(),
+})
+
+const ChatMessageSchema = z.object({
+  message: z.string().min(1, 'Message is required'),
+  userMessageId: z.string().optional(),
+  chatId: z.string().optional(),
+  workflowId: z.string().optional(),
+  workspaceId: z.string().optional(),
+  workflowName: z.string().optional(),
+  model: z.string().optional().default(DEFAULT_MODEL),
+  mode: z.enum(COPILOT_REQUEST_MODES).optional().default('agent'),
+  prefetch: z.boolean().optional(),
+  createNewChat: z.boolean().optional().default(false),
+  implicitFeedback: z.string().optional(),
+  fileAttachments: z.array(FileAttachmentSchema).optional(),
+  resourceAttachments: z.array(ResourceAttachmentSchema).optional(),
+  provider: z.string().optional(),
+  contexts: z.array(ChatContextSchema).optional(),
+  commands: z.array(z.string()).optional(),
+  userTimezone: z.string().optional(),
+})
+
+type UnifiedChatRequest = z.infer<typeof ChatMessageSchema>
+type UnifiedChatBranch =
+  | {
+      kind: 'workflow'
+      workflowId: string
+      workflowName?: string
+      workspaceId?: string
+      selectedModel: string
+      mode: UnifiedChatRequest['mode']
+      provider?: string
+      goRoute: '/api/copilot'
+      titleModel: string
+      titleProvider?: string
+      notifyWorkspaceStatus: false
+      buildPayload: (params: {
+        message: string
+        userId: string
+        userMessageId: string
+        chatId?: string
+        contexts: Array<{ type: string; content: string }>
+        fileAttachments?: UnifiedChatRequest['fileAttachments']
+        userPermission?: string
+        userTimezone?: string
+        workflowId: string
+        workflowName?: string
+        workspaceId?: string
+        mode: UnifiedChatRequest['mode']
+        provider?: string
+        commands?: string[]
+        prefetch?: boolean
+        implicitFeedback?: string
+      }) => Promise<Record<string, unknown>>
+      buildExecutionContext: (params: {
+        userId: string
+        chatId?: string
+        userTimezone?: string
+        messageId: string
+      }) => Promise<ExecutionContext>
+    }
+  | {
+      kind: 'workspace'
+      workspaceId: string
+      goRoute: '/api/mothership'
+      titleModel: string
+      titleProvider?: undefined
+      notifyWorkspaceStatus: true
+      buildPayload: (params: {
+        message: string
+        userId: string
+        userMessageId: string
+        chatId?: string
+        contexts: Array<{ type: string; content: string }>
+        fileAttachments?: UnifiedChatRequest['fileAttachments']
+        userPermission?: string
+        userTimezone?: string
+        workspaceContext?: string
+      }) => Promise<Record<string, unknown>>
+      buildExecutionContext: (params: {
+        userId: string
+        chatId?: string
+        userTimezone?: string
+        messageId: string
+      }) => Promise<ExecutionContext>
+    }
+
+function normalizeContexts(contexts: UnifiedChatRequest['contexts']) {
+  if (!Array.isArray(contexts)) {
+    return contexts
+  }
+
+  return contexts.map((ctx) => {
+    if (ctx.kind !== 'blocks') return ctx
+    if (Array.isArray(ctx.blockIds) && ctx.blockIds.length > 0) return ctx
+    if (ctx.blockId) return { ...ctx, blockIds: [ctx.blockId] }
+    return ctx
+  })
+}
+
+async function resolveAgentContexts(params: {
+  contexts?: UnifiedChatRequest['contexts']
+  resourceAttachments?: UnifiedChatRequest['resourceAttachments']
+  userId: string
+  message: string
+  workspaceId?: string
+  chatId?: string
+  requestId: string
+}): Promise<Array<{ type: string; content: string }>> {
+  const { contexts, resourceAttachments, userId, message, workspaceId, chatId, requestId } = params
+
+  let agentContexts: Array<{ type: string; content: string }> = []
+
+  if (Array.isArray(contexts) && contexts.length > 0) {
+    try {
+      agentContexts = await processContextsServer(
+        contexts as ChatContext[],
+        userId,
+        message,
+        workspaceId,
+        chatId
+      )
+    } catch (error) {
+      logger.error(`[${requestId}] Failed to process contexts`, error)
+    }
+  }
+
+  if (Array.isArray(resourceAttachments) && resourceAttachments.length > 0 && workspaceId) {
+    const results = await Promise.allSettled(
+      resourceAttachments.map(async (resource) => {
+        const ctx = await resolveActiveResourceContext(
+          resource.type,
+          resource.id,
+          workspaceId,
+          userId,
+          chatId
+        )
+        if (!ctx) return null
+        return { ...ctx, tag: resource.active ? '@active_tab' : '@open_tab' }
+      })
+    )
+
+    for (const result of results) {
+      if (result.status === 'fulfilled' && result.value) {
+        agentContexts.push(result.value)
+      } else if (result.status === 'rejected') {
+        logger.error(`[${requestId}] Failed to resolve resource attachment`, result.reason)
+      }
+    }
+  }
+
+  return agentContexts
+}
+
+async function persistUserMessage(params: {
+  chatId?: string
+  userMessageId: string
+  message: string
+  fileAttachments?: UnifiedChatRequest['fileAttachments']
+  contexts?: UnifiedChatRequest['contexts']
+  workspaceId?: string
+  notifyWorkspaceStatus: boolean
+}): Promise<unknown[] | undefined> {
+  const {
+    chatId,
+    userMessageId,
+    message,
+    fileAttachments,
+    contexts,
+    workspaceId,
+    notifyWorkspaceStatus,
+  } = params
+  if (!chatId) return undefined
+
+  const userMsg = buildPersistedUserMessage({
+    id: userMessageId,
+    content: message,
+    fileAttachments,
+    contexts,
+  })
+
+  const [updated] = await db
+    .update(copilotChats)
+    .set({
+      messages: sql`${copilotChats.messages} || ${JSON.stringify([userMsg])}::jsonb`,
+      conversationId: userMessageId,
+      updatedAt: new Date(),
+    })
+    .where(eq(copilotChats.id, chatId))
+    .returning({ messages: copilotChats.messages })
+
+  if (notifyWorkspaceStatus && updated && workspaceId) {
+    taskPubSub?.publishStatusChanged({ workspaceId, chatId, type: 'started' })
+  }
+
+  return Array.isArray(updated?.messages) ? updated.messages : undefined
+}
+
+async function buildInitialExecutionContext(params: {
+  userId: string
+  workflowId?: string
+  workspaceId?: string
+  chatId?: string
+  messageId: string
+  userTimezone?: string
+  requestMode: string
+}): Promise<ExecutionContext> {
+  const { userId, workflowId, workspaceId, chatId, messageId, userTimezone, requestMode } = params
+
+  if (workflowId && !workspaceId) {
+    const context = await prepareExecutionContext(userId, workflowId, chatId)
+    return {
+      ...context,
+      messageId,
+      userTimezone,
+      requestMode,
+      copilotToolExecution: true,
+    }
+  }
+
+  const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
+  return {
+    userId,
+    workflowId: workflowId ?? '',
+    workspaceId,
+    chatId,
+    decryptedEnvVars,
+    messageId,
+    userTimezone,
+    requestMode,
+    copilotToolExecution: true,
+  }
+}
+
+function buildOnComplete(params: {
+  chatId?: string
+  userMessageId: string
+  requestId: string
+  workspaceId?: string
+  notifyWorkspaceStatus: boolean
+}) {
+  const { chatId, userMessageId, requestId, workspaceId, notifyWorkspaceStatus } = params
+
+  return async (result: OrchestratorResult) => {
+    if (!chatId) return
+
+    try {
+      await finalizeAssistantTurn({
+        chatId,
+        userMessageId,
+        ...(result.success
+          ? { assistantMessage: buildPersistedAssistantMessage(result, requestId) }
+          : {}),
+      })
+
+      if (notifyWorkspaceStatus && workspaceId) {
+        taskPubSub?.publishStatusChanged({
+          workspaceId,
+          chatId,
+          type: 'completed',
+        })
+      }
+    } catch (error) {
+      logger.error(`[${requestId}] Failed to persist chat messages`, {
+        chatId,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      })
+    }
+  }
+}
+
+function buildOnError(params: {
+  chatId?: string
+  userMessageId: string
+  requestId: string
+  workspaceId?: string
+  notifyWorkspaceStatus: boolean
+}) {
+  const { chatId, userMessageId, requestId, workspaceId, notifyWorkspaceStatus } = params
+
+  return async () => {
+    if (!chatId) return
+
+    try {
+      await finalizeAssistantTurn({ chatId, userMessageId })
+
+      if (notifyWorkspaceStatus && workspaceId) {
+        taskPubSub?.publishStatusChanged({
+          workspaceId,
+          chatId,
+          type: 'completed',
+        })
+      }
+    } catch (error) {
+      logger.error(`[${requestId}] Failed to finalize errored chat stream`, {
+        chatId,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      })
+    }
+  }
+}
+
+async function resolveBranch(params: {
+  authenticatedUserId: string
+  workflowId?: string
+  workflowName?: string
+  workspaceId?: string
+  model?: string
+  mode?: UnifiedChatRequest['mode']
+  provider?: string
+}): Promise<UnifiedChatBranch | NextResponse> {
+  const {
+    authenticatedUserId,
+    workflowId: providedWorkflowId,
+    workflowName,
+    workspaceId: requestedWorkspaceId,
+    model,
+    mode,
+    provider,
+  } = params
+
+  if (providedWorkflowId || workflowName) {
+    const resolved = await resolveWorkflowIdForUser(
+      authenticatedUserId,
+      providedWorkflowId,
+      workflowName,
+      requestedWorkspaceId
+    )
+    if (!resolved) {
+      return createBadRequestResponse(
+        'No workflows found. Create a workflow first or provide a valid workflowId.'
+      )
+    }
+
+    const resolvedWorkflowId = resolved.workflowId
+    let resolvedWorkspaceId = requestedWorkspaceId
+    if (!resolvedWorkspaceId) {
+      try {
+        const workflow = await getWorkflowById(resolvedWorkflowId)
+        resolvedWorkspaceId = workflow?.workspaceId ?? undefined
+      } catch {
+        // best effort; downstream calls can still proceed
+      }
+    }
+
+    const selectedModel = model || DEFAULT_MODEL
+    return {
+      kind: 'workflow',
+      workflowId: resolvedWorkflowId,
+      workflowName: resolved.workflowName,
+      workspaceId: resolvedWorkspaceId,
+      selectedModel,
+      mode: mode ?? 'agent',
+      provider,
+      goRoute: '/api/copilot',
+      titleModel: selectedModel,
+      titleProvider: provider,
+      notifyWorkspaceStatus: false,
+      buildPayload: async (payloadParams) =>
+        buildCopilotRequestPayload(
+          {
+            message: payloadParams.message,
+            workflowId: payloadParams.workflowId,
+            workflowName: payloadParams.workflowName,
+            workspaceId: payloadParams.workspaceId,
+            userId: payloadParams.userId,
+            userMessageId: payloadParams.userMessageId,
+            mode: payloadParams.mode ?? 'agent',
+            model: selectedModel,
+            provider: payloadParams.provider,
+            contexts: payloadParams.contexts,
+            fileAttachments: payloadParams.fileAttachments,
+            commands: payloadParams.commands,
+            chatId: payloadParams.chatId,
+            prefetch: payloadParams.prefetch,
+            implicitFeedback: payloadParams.implicitFeedback,
+            userPermission: payloadParams.userPermission,
+            userTimezone: payloadParams.userTimezone,
+          },
+          { selectedModel }
+        ),
+      buildExecutionContext: async ({ userId, chatId, userTimezone, messageId }) =>
+        buildInitialExecutionContext({
+          userId,
+          workflowId: resolvedWorkflowId,
+          workspaceId: resolvedWorkspaceId,
+          chatId,
+          messageId,
+          userTimezone,
+          requestMode: mode ?? 'agent',
+        }),
+    }
+  }
+
+  if (!requestedWorkspaceId) {
+    return createBadRequestResponse('workspaceId is required when workflowId is not provided')
+  }
+
+  return {
+    kind: 'workspace',
+    workspaceId: requestedWorkspaceId,
+    goRoute: '/api/mothership',
+    titleModel: DEFAULT_MODEL,
+    notifyWorkspaceStatus: true,
+    buildPayload: async (payloadParams) =>
+      buildCopilotRequestPayload(
+        {
+          message: payloadParams.message,
+          workspaceId: requestedWorkspaceId,
+          userId: payloadParams.userId,
+          userMessageId: payloadParams.userMessageId,
+          mode: 'agent',
+          model: '',
+          contexts: payloadParams.contexts,
+          fileAttachments: payloadParams.fileAttachments,
+          chatId: payloadParams.chatId,
+          workspaceContext: payloadParams.workspaceContext,
+          userPermission: payloadParams.userPermission,
+          userTimezone: payloadParams.userTimezone,
+        },
+        { selectedModel: '' }
+      ),
+    buildExecutionContext: async ({ userId, chatId, userTimezone, messageId }) =>
+      buildInitialExecutionContext({
+        userId,
+        workspaceId: requestedWorkspaceId,
+        chatId,
+        messageId,
+        userTimezone,
+        requestMode: 'agent',
+      }),
+  }
+}
+
+export async function handleUnifiedChatPost(req: NextRequest) {
+  const tracker = createRequestTracker(false)
+  let actualChatId: string | undefined
+  let userMessageId = ''
+  let chatStreamLockAcquired = false
+
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return createUnauthorizedResponse()
+    }
+    const authenticatedUserId = session.user.id
+
+    const body = ChatMessageSchema.parse(await req.json())
+    const normalizedContexts = normalizeContexts(body.contexts)
+    userMessageId = body.userMessageId || crypto.randomUUID()
+
+    const branch = await resolveBranch({
+      authenticatedUserId,
+      workflowId: body.workflowId,
+      workflowName: body.workflowName,
+      workspaceId: body.workspaceId,
+      model: body.model,
+      mode: body.mode,
+      provider: body.provider,
+    })
+    if (branch instanceof NextResponse) {
+      return branch
+    }
+
+    let currentChat: ChatLoadResult['chat'] = null
+    let conversationHistory: unknown[] = []
+    let chatIsNew = false
+    actualChatId = body.chatId
+
+    if (body.chatId || body.createNewChat) {
+      const chatResult = await resolveOrCreateChat({
+        chatId: body.chatId,
+        userId: authenticatedUserId,
+        ...(branch.kind === 'workflow' ? { workflowId: branch.workflowId } : {}),
+        workspaceId: branch.workspaceId,
+        model: branch.titleModel,
+        type: branch.kind === 'workflow' ? 'copilot' : 'mothership',
+      })
+      currentChat = chatResult.chat
+      actualChatId = chatResult.chatId || body.chatId
+      chatIsNew = chatResult.isNew
+      conversationHistory = Array.isArray(chatResult.conversationHistory)
+        ? chatResult.conversationHistory
+        : []
+
+      if (body.chatId && !currentChat) {
+        return NextResponse.json({ error: 'Chat not found' }, { status: 404 })
+      }
+    }
+
+    if (chatIsNew && actualChatId && body.resourceAttachments?.length) {
+      await persistChatResources(
+        actualChatId,
+        body.resourceAttachments.map((r) => ({
+          type: r.type,
+          id: r.id,
+          title: r.title ?? GENERIC_RESOURCE_TITLE[r.type],
+        }))
+      )
+    }
+
+    if (actualChatId) {
+      chatStreamLockAcquired = await acquirePendingChatStream(actualChatId, userMessageId)
+      if (!chatStreamLockAcquired) {
+        const activeStreamId = await getPendingChatStreamId(actualChatId)
+        return NextResponse.json(
+          {
+            error: 'A response is already in progress for this chat.',
+            ...(activeStreamId ? { activeStreamId } : {}),
+          },
+          { status: 409 }
+        )
+      }
+    }
+
+    const workspaceId = branch.workspaceId
+    const userPermissionPromise = workspaceId
+      ? getUserEntityPermissions(authenticatedUserId, 'workspace', workspaceId).catch((error) => {
+          logger.warn('Failed to load user permissions', {
+            error: error instanceof Error ? error.message : String(error),
+            workspaceId,
+          })
+          return null
+        })
+      : Promise.resolve(null)
+    const workspaceContextPromise =
+      branch.kind === 'workspace'
+        ? generateWorkspaceContext(branch.workspaceId, authenticatedUserId)
+        : Promise.resolve(undefined)
+    const agentContextsPromise = resolveAgentContexts({
+      contexts: normalizedContexts,
+      resourceAttachments: body.resourceAttachments,
+      userId: authenticatedUserId,
+      message: body.message,
+      workspaceId,
+      chatId: actualChatId,
+      requestId: tracker.requestId,
+    })
+    const persistedMessagesPromise = persistUserMessage({
+      chatId: actualChatId,
+      userMessageId,
+      message: body.message,
+      fileAttachments: body.fileAttachments,
+      contexts: normalizedContexts,
+      workspaceId,
+      notifyWorkspaceStatus: branch.notifyWorkspaceStatus,
+    })
+    const executionContextPromise = branch.buildExecutionContext({
+      userId: authenticatedUserId,
+      chatId: actualChatId,
+      userTimezone: body.userTimezone,
+      messageId: userMessageId,
+    })
+
+    const [agentContexts, userPermission, workspaceContext, persistedMessages, executionContext] =
+      await Promise.all([
+        agentContextsPromise,
+        userPermissionPromise,
+        workspaceContextPromise,
+        persistedMessagesPromise,
+        executionContextPromise,
+      ])
+
+    if (persistedMessages) {
+      conversationHistory = persistedMessages.filter((message) => {
+        const record = message as Record<string, unknown>
+        return record.id !== userMessageId
+      })
+    }
+
+    const requestPayload =
+      branch.kind === 'workflow'
+        ? await branch.buildPayload({
+            message: body.message,
+            userId: authenticatedUserId,
+            userMessageId,
+            chatId: actualChatId,
+            contexts: agentContexts,
+            fileAttachments: body.fileAttachments,
+            userPermission: userPermission ?? undefined,
+            userTimezone: body.userTimezone,
+            workflowId: branch.workflowId,
+            workflowName: branch.workflowName,
+            workspaceId: branch.workspaceId,
+            mode: branch.mode,
+            provider: branch.provider,
+            commands: body.commands,
+            prefetch: body.prefetch,
+            implicitFeedback: body.implicitFeedback,
+          })
+        : await branch.buildPayload({
+            message: body.message,
+            userId: authenticatedUserId,
+            userMessageId,
+            chatId: actualChatId,
+            contexts: agentContexts,
+            fileAttachments: body.fileAttachments,
+            userPermission: userPermission ?? undefined,
+            userTimezone: body.userTimezone,
+            workspaceContext,
+          })
+
+    const executionId = crypto.randomUUID()
+    const runId = crypto.randomUUID()
+
+    const stream = createSSEStream({
+      requestPayload,
+      userId: authenticatedUserId,
+      streamId: userMessageId,
+      executionId,
+      runId,
+      chatId: actualChatId,
+      currentChat,
+      isNewChat: conversationHistory.length === 0,
+      message: body.message,
+      titleModel: branch.titleModel,
+      ...(branch.titleProvider ? { titleProvider: branch.titleProvider } : {}),
+      requestId: tracker.requestId,
+      workspaceId,
+      orchestrateOptions: {
+        userId: authenticatedUserId,
+        ...(branch.kind === 'workflow' ? { workflowId: branch.workflowId } : {}),
+        ...(branch.kind === 'workspace' ? { workspaceId: branch.workspaceId } : {}),
+        chatId: actualChatId,
+        executionId,
+        runId,
+        goRoute: branch.goRoute,
+        autoExecuteTools: true,
+        interactive: true,
+        executionContext,
+        onComplete: buildOnComplete({
+          chatId: actualChatId,
+          userMessageId,
+          requestId: tracker.requestId,
+          workspaceId,
+          notifyWorkspaceStatus: branch.notifyWorkspaceStatus,
+        }),
+        onError: buildOnError({
+          chatId: actualChatId,
+          userMessageId,
+          requestId: tracker.requestId,
+          workspaceId,
+          notifyWorkspaceStatus: branch.notifyWorkspaceStatus,
+        }),
+      },
+    })
+
+    return new Response(stream, { headers: SSE_RESPONSE_HEADERS })
+  } catch (error) {
+    if (chatStreamLockAcquired && actualChatId && userMessageId) {
+      await releasePendingChatStream(actualChatId, userMessageId)
+    }
+
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: 'Invalid request data', details: error.errors },
+        { status: 400 }
+      )
+    }
+
+    logger.error(`[${tracker.requestId}] Error handling unified chat request`, {
+      error: error instanceof Error ? error.message : 'Unknown error',
+      stack: error instanceof Error ? error.stack : undefined,
+    })
+
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
diff --git a/apps/sim/lib/copilot/process-contents.ts b/apps/sim/lib/copilot/chat/process-contents.ts
similarity index 91%
rename from apps/sim/lib/copilot/process-contents.ts
rename to apps/sim/lib/copilot/chat/process-contents.ts
index 9673a124aeb..89fc036c243 100644
--- a/apps/sim/lib/copilot/process-contents.ts
+++ b/apps/sim/lib/copilot/chat/process-contents.ts
@@ -19,9 +19,9 @@ import { checkKnowledgeBaseAccess } from '@/app/api/knowledge/utils'
 import { isHiddenFromDisplay } from '@/blocks/types'
 import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-check'
 import { escapeRegExp } from '@/executor/constants'
-import type { ChatContext } from '@/stores/panel/copilot/types'
+import type { ChatContext } from '@/stores/panel'
 
-export type AgentContextType =
+type AgentContextType =
   | 'past_chat'
   | 'workflow'
   | 'current_workflow'
@@ -36,7 +36,7 @@ export type AgentContextType =
   | 'folder'
   | 'active_resource'
 
-export interface AgentContext {
+interface AgentContext {
   type: AgentContextType
   tag: string
   content: string
@@ -44,62 +44,6 @@ export interface AgentContext {
 
 const logger = createLogger('ProcessContents')
 
-export async function processContexts(
-  contexts: ChatContext[] | undefined
-): Promise<AgentContext[]> {
-  if (!Array.isArray(contexts) || contexts.length === 0) return []
-  const tasks = contexts.map(async (ctx) => {
-    try {
-      if (ctx.kind === 'past_chat') {
-        return await processPastChatViaApi(ctx.chatId, ctx.label ? `@${ctx.label}` : '@')
-      }
-      if ((ctx.kind === 'workflow' || ctx.kind === 'current_workflow') && ctx.workflowId) {
-        return await processWorkflowFromDb(
-          ctx.workflowId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@',
-          ctx.kind
-        )
-      }
-      if (ctx.kind === 'knowledge' && ctx.knowledgeId) {
-        return await processKnowledgeFromDb(
-          ctx.knowledgeId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@'
-        )
-      }
-      if (ctx.kind === 'blocks' && ctx.blockIds?.length > 0) {
-        return await processBlockMetadata(ctx.blockIds[0], ctx.label ? `@${ctx.label}` : '@')
-      }
-      if (ctx.kind === 'templates' && ctx.templateId) {
-        return await processTemplateFromDb(
-          ctx.templateId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@'
-        )
-      }
-      if (ctx.kind === 'logs' && ctx.executionId) {
-        return await processExecutionLogFromDb(
-          ctx.executionId,
-          undefined,
-          ctx.label ? `@${ctx.label}` : '@'
-        )
-      }
-      if (ctx.kind === 'workflow_block' && ctx.workflowId && ctx.blockId) {
-        return await processWorkflowBlockFromDb(ctx.workflowId, undefined, ctx.blockId, ctx.label)
-      }
-      // Other kinds can be added here: workflow, blocks, logs, knowledge, templates, docs
-      return null
-    } catch (error) {
-      logger.error('Failed processing context', { ctx, error })
-      return null
-    }
-  })
-
-  const results = await Promise.all(tasks)
-  return results.filter((r): r is AgentContext => !!r) as AgentContext[]
-}
-
 // Server-side variant (recommended for use in API routes)
 export async function processContextsServer(
   contexts: ChatContext[] | undefined,
@@ -271,7 +215,7 @@ async function processPastChatFromDb(
   currentWorkspaceId?: string
 ): Promise<AgentContext | null> {
   try {
-    const { getAccessibleCopilotChat } = await import('@/lib/copilot/chat-lifecycle')
+    const { getAccessibleCopilotChat } = await import('./lifecycle')
     const chat = await getAccessibleCopilotChat(chatId, userId)
     if (!chat) {
       return null
@@ -398,7 +342,7 @@ async function processWorkflowFromDb(
 
 async function processPastChat(chatId: string, tagOverride?: string): Promise<AgentContext | null> {
   try {
-    const resp = await fetch(`/api/copilot/chat/${encodeURIComponent(chatId)}`)
+    const resp = await fetch(`/api/mothership/chat?chatId=${encodeURIComponent(chatId)}`)
     if (!resp.ok) {
       logger.error('Failed to fetch past chat', { chatId, status: resp.status })
       return null
diff --git a/apps/sim/lib/copilot/chat/terminal-state.test.ts b/apps/sim/lib/copilot/chat/terminal-state.test.ts
new file mode 100644
index 00000000000..a9705573360
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/terminal-state.test.ts
@@ -0,0 +1,115 @@
+/**
+ * @vitest-environment node
+ */
+
+import { copilotChats } from '@sim/db/schema'
+import { and, eq } from 'drizzle-orm'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { selectLimit, selectWhere, selectFrom, select, updateWhere, updateSet, update } = vi.hoisted(
+  () => {
+    const selectLimit = vi.fn()
+    const selectWhere = vi.fn(() => ({ limit: selectLimit }))
+    const selectFrom = vi.fn(() => ({ where: selectWhere }))
+    const select = vi.fn(() => ({ from: selectFrom }))
+
+    const updateWhere = vi.fn()
+    const updateSet = vi.fn(() => ({ where: updateWhere }))
+    const update = vi.fn(() => ({ set: updateSet }))
+
+    return {
+      selectLimit,
+      selectWhere,
+      selectFrom,
+      select,
+      updateWhere,
+      updateSet,
+      update,
+    }
+  }
+)
+
+vi.mock('@sim/db', () => ({
+  db: {
+    select,
+    update,
+  },
+}))
+
+import { finalizeAssistantTurn } from './terminal-state'
+
+describe('finalizeAssistantTurn', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    updateWhere.mockResolvedValue(undefined)
+  })
+
+  it('appends the assistant message when the user turn is still last', async () => {
+    selectLimit.mockResolvedValue([
+      {
+        messages: [{ id: 'user-1', role: 'user', content: 'hello' }],
+      },
+    ])
+
+    await finalizeAssistantTurn({
+      chatId: 'chat-1',
+      userMessageId: 'user-1',
+      assistantMessage: {
+        id: 'assistant-1',
+        role: 'assistant',
+        content: 'hi',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      },
+    })
+
+    expect(updateSet).toHaveBeenCalledWith(
+      expect.objectContaining({
+        updatedAt: expect.any(Date),
+        conversationId: null,
+        messages: expect.anything(),
+      })
+    )
+    expect(updateWhere).toHaveBeenCalledWith(
+      and(eq(copilotChats.id, 'chat-1'), eq(copilotChats.conversationId, 'user-1'))
+    )
+  })
+
+  it('only clears the active stream marker when a response is already persisted', async () => {
+    selectLimit.mockResolvedValue([
+      {
+        messages: [
+          { id: 'user-1', role: 'user', content: 'hello' },
+          { id: 'assistant-1', role: 'assistant', content: 'partial' },
+        ],
+      },
+    ])
+
+    await finalizeAssistantTurn({
+      chatId: 'chat-1',
+      userMessageId: 'user-1',
+      assistantMessage: {
+        id: 'assistant-2',
+        role: 'assistant',
+        content: 'final',
+        timestamp: '2024-01-01T00:00:00.000Z',
+      },
+    })
+
+    const updateCalls = updateSet.mock.calls as unknown as Array<[Record<string, unknown>]>
+    const updateArg = updateCalls[0]?.[0]
+    expect(updateArg).toBeDefined()
+    if (!updateArg) {
+      throw new Error('Expected updateSet to be called')
+    }
+    expect(updateArg).toEqual(
+      expect.objectContaining({
+        updatedAt: expect.any(Date),
+        conversationId: null,
+      })
+    )
+    expect(Object.hasOwn(updateArg, 'messages')).toBe(false)
+    expect(updateWhere).toHaveBeenCalledWith(
+      and(eq(copilotChats.id, 'chat-1'), eq(copilotChats.conversationId, 'user-1'))
+    )
+  })
+})
diff --git a/apps/sim/lib/copilot/chat/terminal-state.ts b/apps/sim/lib/copilot/chat/terminal-state.ts
new file mode 100644
index 00000000000..f09c1c861bb
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/terminal-state.ts
@@ -0,0 +1,57 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { and, eq, sql } from 'drizzle-orm'
+import type { PersistedMessage } from '@/lib/copilot/chat/persisted-message'
+
+interface FinalizeAssistantTurnParams {
+  chatId: string
+  userMessageId: string
+  assistantMessage?: PersistedMessage
+}
+
+/**
+ * Clear the active stream marker for a chat and optionally append the assistant
+ * message if a response has not already been persisted immediately after the
+ * triggering user message.
+ */
+export async function finalizeAssistantTurn({
+  chatId,
+  userMessageId,
+  assistantMessage,
+}: FinalizeAssistantTurnParams): Promise<void> {
+  const [row] = await db
+    .select({ messages: copilotChats.messages })
+    .from(copilotChats)
+    .where(eq(copilotChats.id, chatId))
+    .limit(1)
+
+  const messages: Record<string, unknown>[] = Array.isArray(row?.messages) ? row.messages : []
+  const userIdx = messages.findIndex((message) => message.id === userMessageId)
+  const alreadyHasResponse =
+    userIdx >= 0 &&
+    userIdx + 1 < messages.length &&
+    (messages[userIdx + 1] as Record<string, unknown>)?.role === 'assistant'
+  const canAppendAssistant = userIdx >= 0 && userIdx === messages.length - 1 && !alreadyHasResponse
+  const updateWhere = and(
+    eq(copilotChats.id, chatId),
+    eq(copilotChats.conversationId, userMessageId)
+  )
+
+  const baseUpdate = {
+    conversationId: null,
+    updatedAt: new Date(),
+  }
+
+  if (assistantMessage && canAppendAssistant) {
+    await db
+      .update(copilotChats)
+      .set({
+        ...baseUpdate,
+        messages: sql`${copilotChats.messages} || ${JSON.stringify([assistantMessage])}::jsonb`,
+      })
+      .where(updateWhere)
+    return
+  }
+
+  await db.update(copilotChats).set(baseUpdate).where(updateWhere)
+}
diff --git a/apps/sim/lib/copilot/workspace-context.ts b/apps/sim/lib/copilot/chat/workspace-context.ts
similarity index 78%
rename from apps/sim/lib/copilot/workspace-context.ts
rename to apps/sim/lib/copilot/chat/workspace-context.ts
index ec8f1964ed3..fb7128b3655 100644
--- a/apps/sim/lib/copilot/workspace-context.ts
+++ b/apps/sim/lib/copilot/chat/workspace-context.ts
@@ -1,16 +1,16 @@
 import { db } from '@sim/db'
 import {
-  copilotChats,
   knowledgeBase,
   knowledgeConnector,
   mcpServers,
   userTableDefinitions,
   userTableRows,
   workflow,
+  workflowFolder,
   workflowSchedule,
 } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, count, desc, eq, inArray, isNull } from 'drizzle-orm'
+import { and, count, eq, inArray, isNull } from 'drizzle-orm'
 import { getAccessibleOAuthCredentials } from '@/lib/credentials/environment'
 import { listWorkspaceFiles } from '@/lib/uploads/contexts/workspace'
 import { listCustomTools } from '@/lib/workflows/custom-tools/operations'
@@ -46,6 +46,7 @@ export interface WorkspaceMdData {
     description?: string | null
     isDeployed: boolean
     lastRunAt?: Date | null
+    folderPath?: string | null
   }>
   knowledgeBases: Array<{
     id: string
@@ -54,9 +55,10 @@ export interface WorkspaceMdData {
     connectorTypes?: string[]
   }>
   tables: Array<{ id: string; name: string; description?: string | null; rowCount: number }>
-  files: Array<{ name: string; type: string; size: number }>
-  credentials: Array<{ providerId: string }>
-  tasks: Array<{ id: string; title: string; updatedAt: Date }>
+  files: Array<{ id: string; name: string; type: string; size: number }>
+  oauthIntegrations: Array<{ providerId: string }>
+  envVariables: string[]
+  tasks?: Array<{ id: string; title: string; updatedAt: Date }>
   customTools?: Array<{ id: string; name: string }>
   mcpServers?: Array<{ id: string; name: string; url?: string | null; enabled: boolean }>
   skills?: Array<{ id: string; name: string; description: string }>
@@ -93,15 +95,40 @@ export function buildWorkspaceMd(data: WorkspaceMdData): string {
   }
 
   if (data.workflows.length > 0) {
-    const lines = data.workflows.map((wf) => {
-      const parts = [`- **${wf.name}** (${wf.id})`]
-      if (wf.description) parts.push(`  ${wf.description}`)
+    const rootWorkflows: typeof data.workflows = []
+    const folderWorkflows = new Map<string, typeof data.workflows>()
+
+    for (const wf of data.workflows) {
+      if (wf.folderPath) {
+        const existing = folderWorkflows.get(wf.folderPath) ?? []
+        existing.push(wf)
+        folderWorkflows.set(wf.folderPath, existing)
+      } else {
+        rootWorkflows.push(wf)
+      }
+    }
+
+    const formatWf = (wf: (typeof data.workflows)[0], indent: string) => {
+      const parts = [`${indent}- **${wf.name}** (${wf.id})`]
+      if (wf.description) parts.push(`${indent}  ${wf.description}`)
       const flags: string[] = []
       if (wf.isDeployed) flags.push('deployed')
       if (wf.lastRunAt) flags.push(`last run: ${wf.lastRunAt.toISOString().split('T')[0]}`)
       if (flags.length > 0) parts[0] += ` — ${flags.join(', ')}`
       return parts.join('\n')
-    })
+    }
+
+    const lines: string[] = []
+    for (const wf of rootWorkflows) {
+      lines.push(formatWf(wf, ''))
+    }
+    const sortedFolders = [...folderWorkflows.entries()].sort((a, b) => a[0].localeCompare(b[0]))
+    for (const [folder, wfs] of sortedFolders) {
+      lines.push(`- 📁 **${folder}/**`)
+      for (const wf of wfs) {
+        lines.push(formatWf(wf, '  '))
+      }
+    }
     sections.push(`## Workflows (${data.workflows.length})\n${lines.join('\n')}`)
   } else {
     sections.push('## Workflows (0)\n(none)')
@@ -133,21 +160,28 @@ export function buildWorkspaceMd(data: WorkspaceMdData): string {
   }
 
   if (data.files.length > 0) {
-    const lines = data.files.map((f) => `- **${f.name}** (${f.type}, ${formatSize(f.size)})`)
+    const lines = data.files.map(
+      (f) => `- **${f.name}** (${f.id}) — ${f.type}, ${formatSize(f.size)}`
+    )
     sections.push(`## Files (${data.files.length})\n${lines.join('\n')}`)
   } else {
     sections.push('## Files (0)\n(none)')
   }
 
-  if (data.credentials.length > 0) {
-    const providers = [...new Set(data.credentials.map((c) => c.providerId))]
+  if (data.oauthIntegrations.length > 0) {
+    const providers = [...new Set(data.oauthIntegrations.map((c) => c.providerId))]
     const lines = providers.map((p) => {
       const services = PROVIDER_SERVICES[p]
       return services ? `- ${p} (${services.join(', ')})` : `- ${p}`
     })
-    sections.push(`## Connected Services\n${lines.join('\n')}`)
+    sections.push(`## Connected Integrations\n${lines.join('\n')}`)
   } else {
-    sections.push('## Connected Services\n(none)')
+    sections.push('## Connected Integrations\n(none)')
+  }
+
+  if (data.envVariables.length > 0) {
+    const lines = data.envVariables.map((v) => `- ${v}`)
+    sections.push(`## Environment Variables (${data.envVariables.length})\n${lines.join('\n')}`)
   }
 
   if (data.customTools && data.customTools.length > 0) {
@@ -182,14 +216,6 @@ export function buildWorkspaceMd(data: WorkspaceMdData): string {
     sections.push(`## Jobs (${data.jobs.length})\n${lines.join('\n')}`)
   }
 
-  if (data.tasks.length > 0) {
-    const lines = data.tasks.map((t) => {
-      const date = t.updatedAt.toISOString().split('T')[0]
-      return `- **${t.title || 'Untitled'}** (${t.id}) — ${date}`
-    })
-    sections.push(`## Recent Tasks (${data.tasks.length})\n${lines.join('\n')}`)
-  }
-
   return sections.join('\n\n')
 }
 
@@ -212,11 +238,11 @@ export async function generateWorkspaceContext(
     const [
       members,
       workflows,
+      folderRows,
       kbs,
       tables,
       files,
       credentials,
-      recentTasks,
       customTools,
       mcpServerRows,
       skillRows,
@@ -231,10 +257,20 @@ export async function generateWorkspaceContext(
           description: workflow.description,
           isDeployed: workflow.isDeployed,
           lastRunAt: workflow.lastRunAt,
+          folderId: workflow.folderId,
         })
         .from(workflow)
         .where(and(eq(workflow.workspaceId, workspaceId), isNull(workflow.archivedAt))),
 
+      db
+        .select({
+          id: workflowFolder.id,
+          name: workflowFolder.name,
+          parentId: workflowFolder.parentId,
+        })
+        .from(workflowFolder)
+        .where(and(eq(workflowFolder.workspaceId, workspaceId), isNull(workflowFolder.archivedAt))),
+
       db
         .select({
           id: knowledgeBase.id,
@@ -262,23 +298,6 @@ export async function generateWorkspaceContext(
 
       getAccessibleOAuthCredentials(workspaceId, userId),
 
-      db
-        .select({
-          id: copilotChats.id,
-          title: copilotChats.title,
-          updatedAt: copilotChats.updatedAt,
-        })
-        .from(copilotChats)
-        .where(
-          and(
-            eq(copilotChats.workspaceId, workspaceId),
-            eq(copilotChats.userId, userId),
-            eq(copilotChats.type, 'mothership')
-          )
-        )
-        .orderBy(desc(copilotChats.updatedAt))
-        .limit(5),
-
       listCustomTools({ userId, workspaceId }),
 
       db
@@ -352,22 +371,34 @@ export async function generateWorkspaceContext(
       connectorTypesByKb.set(row.knowledgeBaseId, types)
     }
 
+    const folderPathMap = new Map<string, string>()
+    const folderById = new Map(folderRows.map((f) => [f.id, f]))
+    function resolveFolderPath(id: string): string {
+      const cached = folderPathMap.get(id)
+      if (cached !== undefined) return cached
+      const folder = folderById.get(id)
+      if (!folder) return id
+      const parentPath = folder.parentId ? resolveFolderPath(folder.parentId) : ''
+      const path = parentPath ? `${parentPath}/${folder.name}` : folder.name
+      folderPathMap.set(id, path)
+      return path
+    }
+
     return buildWorkspaceMd({
       workspace: wsRow,
       members,
-      workflows,
+      workflows: workflows.map((wf) => ({
+        ...wf,
+        folderPath: wf.folderId ? resolveFolderPath(wf.folderId) : null,
+      })),
       knowledgeBases: kbs.map((kb) => ({
         ...kb,
         connectorTypes: connectorTypesByKb.get(kb.id),
       })),
       tables: tables.map((t, i) => ({ ...t, rowCount: rowCounts[i] ?? 0 })),
-      files: files.map((f) => ({ name: f.name, type: f.type, size: f.size })),
-      credentials: credentials.map((c) => ({ providerId: c.providerId })),
-      tasks: recentTasks.map((t) => ({
-        id: t.id,
-        title: t.title || 'Untitled',
-        updatedAt: t.updatedAt,
-      })),
+      files: files.map((f) => ({ id: f.id, name: f.name, type: f.type, size: f.size })),
+      oauthIntegrations: credentials.map((c) => ({ providerId: c.providerId })),
+      envVariables: [],
       customTools: customTools.map((t) => ({ id: t.id, name: t.title })),
       mcpServers: mcpServerRows,
       skills: skillRows.map((s) => ({ id: s.id, name: s.name, description: s.description })),
@@ -388,7 +419,7 @@ export async function generateWorkspaceContext(
       workspaceId,
       error: err instanceof Error ? err.message : String(err),
     })
-    return '## Workspace\n(unavailable)\n\n## Workflows\n(unavailable)\n\n## Knowledge Bases\n(unavailable)\n\n## Tables\n(unavailable)\n\n## Files\n(unavailable)\n\n## Credentials\n(unavailable)'
+    return '## Workspace\n(unavailable)\n\n## Workflows\n(unavailable)\n\n## Knowledge Bases\n(unavailable)\n\n## Tables\n(unavailable)\n\n## Files\n(unavailable)\n\n## Connected Integrations\n(unavailable)'
   }
 }
 
diff --git a/apps/sim/lib/copilot/client-sse/types.ts b/apps/sim/lib/copilot/client-sse/types.ts
deleted file mode 100644
index 128ec75d872..00000000000
--- a/apps/sim/lib/copilot/client-sse/types.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type {
-  ChatContext,
-  CopilotToolCall,
-  SubAgentContentBlock,
-} from '@/stores/panel/copilot/types'
-
-/**
- * A content block used in copilot messages and during streaming.
- * Uses a literal type union for `type` to stay compatible with CopilotMessage.
- */
-export type ContentBlockType = 'text' | 'thinking' | 'tool_call' | 'contexts'
-
-export interface ClientContentBlock {
-  type: ContentBlockType
-  content?: string
-  timestamp: number
-  toolCall?: CopilotToolCall | null
-  startTime?: number
-  duration?: number
-  contexts?: ChatContext[]
-}
-
-export interface StreamingContext {
-  messageId: string
-  requestId?: string
-  accumulatedContent: string
-  contentBlocks: ClientContentBlock[]
-  currentTextBlock: ClientContentBlock | null
-  isInThinkingBlock: boolean
-  currentThinkingBlock: ClientContentBlock | null
-  isInDesignWorkflowBlock: boolean
-  designWorkflowContent: string
-  pendingContent: string
-  newChatId?: string
-  doneEventCount: number
-  streamComplete?: boolean
-  wasAborted?: boolean
-  suppressContinueOption?: boolean
-  subAgentParentToolCallId?: string
-  subAgentParentStack: string[]
-  subAgentContent: Record<string, string>
-  subAgentToolCalls: Record<string, CopilotToolCall[]>
-  subAgentBlocks: Record<string, SubAgentContentBlock[]>
-  suppressStreamingUpdates?: boolean
-  activeCompactionId?: string
-}
-
-export type ClientStreamingContext = StreamingContext
diff --git a/apps/sim/lib/copilot/constants.ts b/apps/sim/lib/copilot/constants.ts
index fbf4e312957..1718cfc1d9d 100644
--- a/apps/sim/lib/copilot/constants.ts
+++ b/apps/sim/lib/copilot/constants.ts
@@ -10,13 +10,6 @@ export const SIM_AGENT_API_URL =
     ? rawAgentUrl
     : SIM_AGENT_API_URL_DEFAULT
 
-// ---------------------------------------------------------------------------
-// Redis key prefixes
-// ---------------------------------------------------------------------------
-
-/** Redis key prefix for copilot SSE stream buffers. */
-export const REDIS_COPILOT_STREAM_PREFIX = 'copilot_stream:'
-
 // ---------------------------------------------------------------------------
 // Timeouts
 // ---------------------------------------------------------------------------
@@ -31,47 +24,18 @@ export const STREAM_TIMEOUT_MS = 3_600_000
 // Stream resume
 // ---------------------------------------------------------------------------
 
-/** Maximum number of resume attempts before giving up. */
-export const MAX_RESUME_ATTEMPTS = 3
-
 /** SessionStorage key for persisting active stream metadata across page reloads. */
 export const STREAM_STORAGE_KEY = 'copilot_active_stream'
 
-// ---------------------------------------------------------------------------
-// Client-side streaming batching
-// ---------------------------------------------------------------------------
-
-/** Delay (ms) before processing the next queued message after stream completion. */
-export const QUEUE_PROCESS_DELAY_MS = 100
-
-/** Delay (ms) before invalidating subscription queries after stream completion. */
-export const SUBSCRIPTION_INVALIDATE_DELAY_MS = 1_000
-
-// ---------------------------------------------------------------------------
-// UI helpers
-// ---------------------------------------------------------------------------
-
-/** Maximum character length for an optimistic chat title derived from a user message. */
-export const OPTIMISTIC_TITLE_MAX_LENGTH = 50
-
 // ---------------------------------------------------------------------------
 // Copilot API paths (client-side fetch targets)
 // ---------------------------------------------------------------------------
 
-/** POST — send a chat message to the copilot. */
-export const COPILOT_CHAT_API_PATH = '/api/copilot/chat'
-
-/** POST — send a workspace-scoped chat message (mothership). */
+/** POST — send a chat message through the unified mothership chat surface. */
 export const MOTHERSHIP_CHAT_API_PATH = '/api/mothership/chat'
 
-/** GET — resume/replay a copilot SSE stream. */
-export const COPILOT_CHAT_STREAM_API_PATH = '/api/copilot/chat/stream'
-
-/** POST — persist chat messages / plan artifact / config. */
-export const COPILOT_UPDATE_MESSAGES_API_PATH = '/api/copilot/chat/update-messages'
-
-/** DELETE — delete a copilot chat. */
-export const COPILOT_DELETE_CHAT_API_PATH = '/api/copilot/chat/delete'
+/** Backwards-compatible alias while remaining callers migrate. */
+export const COPILOT_CHAT_API_PATH = MOTHERSHIP_CHAT_API_PATH
 
 /** POST — confirm or reject a tool call. */
 export const COPILOT_CONFIRM_API_PATH = '/api/copilot/confirm'
@@ -79,24 +43,31 @@ export const COPILOT_CONFIRM_API_PATH = '/api/copilot/confirm'
 /** POST — forward diff-accepted/rejected stats to the copilot backend. */
 export const COPILOT_STATS_API_PATH = '/api/copilot/stats'
 
-/** GET — load checkpoints for a chat. */
-export const COPILOT_CHECKPOINTS_API_PATH = '/api/copilot/checkpoints'
+// ---------------------------------------------------------------------------
+// Dedup limits
+// ---------------------------------------------------------------------------
+
+/** Maximum entries in the in-memory SSE tool-event dedup cache. */
+export const STREAM_BUFFER_MAX_DEDUP_ENTRIES = 1_000
 
-/** POST — revert to a checkpoint. */
-export const COPILOT_CHECKPOINTS_REVERT_API_PATH = '/api/copilot/checkpoints/revert'
+// ---------------------------------------------------------------------------
+// Tool result size limits
+// ---------------------------------------------------------------------------
 
-/** GET/POST/DELETE — manage auto-allowed tools. */
-export const COPILOT_AUTO_ALLOWED_TOOLS_API_PATH = '/api/copilot/auto-allowed-tools'
+/** Approximate max inline tool-result budget before artifact/error handling takes over. */
+export const TOOL_RESULT_MAX_INLINE_TOKENS = 50_000
 
-/** GET — fetch dynamically available copilot models. */
-export const COPILOT_MODELS_API_PATH = '/api/copilot/models'
+/** Rough chars-per-token estimate used when only serialized text length is available. */
+export const TOOL_RESULT_ESTIMATED_CHARS_PER_TOKEN = 4
 
-/** GET — fetch user credentials for masking. */
-export const COPILOT_CREDENTIALS_API_PATH = '/api/copilot/credentials'
+/** Approximate max inline tool-result size in characters. */
+export const TOOL_RESULT_MAX_INLINE_CHARS =
+  TOOL_RESULT_MAX_INLINE_TOKENS * TOOL_RESULT_ESTIMATED_CHARS_PER_TOKEN
 
 // ---------------------------------------------------------------------------
-// Dedup limits
+// Copilot modes
 // ---------------------------------------------------------------------------
 
-/** Maximum entries in the in-memory SSE tool-event dedup cache. */
-export const STREAM_BUFFER_MAX_DEDUP_ENTRIES = 1_000
+export const COPILOT_MODES = ['ask', 'build', 'plan'] as const
+
+export const COPILOT_REQUEST_MODES = ['ask', 'build', 'plan', 'agent'] as const
diff --git a/apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts b/apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts
new file mode 100644
index 00000000000..6394988d439
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts
@@ -0,0 +1,1420 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+// Generated from copilot/contracts/mothership-stream-v1.schema.json
+//
+
+export type JsonSchema = unknown
+
+export const MOTHERSHIP_STREAM_V1_SCHEMA: JsonSchema = {
+  $defs: {
+    MothershipStreamV1AdditionalPropertiesMap: {
+      additionalProperties: true,
+      type: 'object',
+    },
+    MothershipStreamV1AsyncToolRecordStatus: {
+      enum: ['pending', 'running', 'completed', 'failed', 'cancelled', 'delivered'],
+      type: 'string',
+    },
+    MothershipStreamV1CheckpointPauseEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1CheckpointPausePayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['run'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1CheckpointPauseFrame: {
+      additionalProperties: false,
+      properties: {
+        parentToolCallId: {
+          type: 'string',
+        },
+        parentToolName: {
+          type: 'string',
+        },
+        pendingToolIds: {
+          items: {
+            type: 'string',
+          },
+          type: 'array',
+        },
+      },
+      required: ['parentToolCallId', 'parentToolName', 'pendingToolIds'],
+      type: 'object',
+    },
+    MothershipStreamV1CheckpointPausePayload: {
+      additionalProperties: false,
+      properties: {
+        checkpointId: {
+          type: 'string',
+        },
+        executionId: {
+          type: 'string',
+        },
+        frames: {
+          items: {
+            $ref: '#/$defs/MothershipStreamV1CheckpointPauseFrame',
+          },
+          type: 'array',
+        },
+        kind: {
+          enum: ['checkpoint_pause'],
+          type: 'string',
+        },
+        pendingToolCallIds: {
+          items: {
+            type: 'string',
+          },
+          type: 'array',
+        },
+        runId: {
+          type: 'string',
+        },
+      },
+      required: ['kind', 'checkpointId', 'runId', 'executionId', 'pendingToolCallIds'],
+      type: 'object',
+    },
+    MothershipStreamV1CompactionDoneData: {
+      additionalProperties: false,
+      properties: {
+        summary_chars: {
+          type: 'integer',
+        },
+      },
+      required: ['summary_chars'],
+      type: 'object',
+    },
+    MothershipStreamV1CompactionDoneEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1CompactionDonePayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['run'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1CompactionDonePayload: {
+      additionalProperties: false,
+      properties: {
+        data: {
+          $ref: '#/$defs/MothershipStreamV1CompactionDoneData',
+        },
+        kind: {
+          enum: ['compaction_done'],
+          type: 'string',
+        },
+      },
+      required: ['kind'],
+      type: 'object',
+    },
+    MothershipStreamV1CompactionStartEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1CompactionStartPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['run'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1CompactionStartPayload: {
+      additionalProperties: false,
+      properties: {
+        kind: {
+          enum: ['compaction_start'],
+          type: 'string',
+        },
+      },
+      required: ['kind'],
+      type: 'object',
+    },
+    MothershipStreamV1CompleteEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1CompletePayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['complete'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1CompletePayload: {
+      additionalProperties: false,
+      properties: {
+        cost: {
+          $ref: '#/$defs/MothershipStreamV1CostData',
+        },
+        reason: {
+          type: 'string',
+        },
+        response: true,
+        status: {
+          $ref: '#/$defs/MothershipStreamV1CompletionStatus',
+        },
+        usage: {
+          $ref: '#/$defs/MothershipStreamV1UsageData',
+        },
+      },
+      required: ['status'],
+      type: 'object',
+    },
+    MothershipStreamV1CompletionStatus: {
+      enum: ['complete', 'error', 'cancelled'],
+      type: 'string',
+    },
+    MothershipStreamV1CostData: {
+      additionalProperties: false,
+      properties: {
+        input: {
+          type: 'number',
+        },
+        output: {
+          type: 'number',
+        },
+        total: {
+          type: 'number',
+        },
+      },
+      type: 'object',
+    },
+    MothershipStreamV1ErrorEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1ErrorPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['error'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1ErrorPayload: {
+      additionalProperties: false,
+      properties: {
+        code: {
+          type: 'string',
+        },
+        data: true,
+        displayMessage: {
+          type: 'string',
+        },
+        error: {
+          type: 'string',
+        },
+        message: {
+          type: 'string',
+        },
+        provider: {
+          type: 'string',
+        },
+      },
+      required: ['message'],
+      type: 'object',
+    },
+    MothershipStreamV1EventEnvelopeCommon: {
+      additionalProperties: false,
+      properties: {
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream'],
+      type: 'object',
+    },
+    MothershipStreamV1EventType: {
+      enum: ['session', 'text', 'tool', 'span', 'resource', 'run', 'error', 'complete'],
+      type: 'string',
+    },
+    MothershipStreamV1ResourceDescriptor: {
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: 'string',
+        },
+        title: {
+          type: 'string',
+        },
+        type: {
+          type: 'string',
+        },
+      },
+      required: ['type', 'id'],
+      type: 'object',
+    },
+    MothershipStreamV1ResourceOp: {
+      enum: ['upsert', 'remove'],
+      type: 'string',
+    },
+    MothershipStreamV1ResourceRemoveEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1ResourceRemovePayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['resource'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1ResourceRemovePayload: {
+      additionalProperties: false,
+      properties: {
+        op: {
+          enum: ['remove'],
+          type: 'string',
+        },
+        resource: {
+          $ref: '#/$defs/MothershipStreamV1ResourceDescriptor',
+        },
+      },
+      required: ['op', 'resource'],
+      type: 'object',
+    },
+    MothershipStreamV1ResourceUpsertEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1ResourceUpsertPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['resource'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1ResourceUpsertPayload: {
+      additionalProperties: false,
+      properties: {
+        op: {
+          enum: ['upsert'],
+          type: 'string',
+        },
+        resource: {
+          $ref: '#/$defs/MothershipStreamV1ResourceDescriptor',
+        },
+      },
+      required: ['op', 'resource'],
+      type: 'object',
+    },
+    MothershipStreamV1ResumeRequest: {
+      additionalProperties: false,
+      properties: {
+        checkpointId: {
+          type: 'string',
+        },
+        results: {
+          items: {
+            $ref: '#/$defs/MothershipStreamV1ResumeToolResult',
+          },
+          type: 'array',
+        },
+        streamId: {
+          type: 'string',
+        },
+      },
+      required: ['streamId', 'checkpointId', 'results'],
+      type: 'object',
+    },
+    MothershipStreamV1ResumeToolResult: {
+      additionalProperties: false,
+      properties: {
+        error: {
+          type: 'string',
+        },
+        output: true,
+        success: {
+          type: 'boolean',
+        },
+        toolCallId: {
+          type: 'string',
+        },
+      },
+      required: ['toolCallId', 'success'],
+      type: 'object',
+    },
+    MothershipStreamV1RunKind: {
+      enum: ['checkpoint_pause', 'resumed', 'compaction_start', 'compaction_done'],
+      type: 'string',
+    },
+    MothershipStreamV1RunResumedEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1RunResumedPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['run'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1RunResumedPayload: {
+      additionalProperties: false,
+      properties: {
+        kind: {
+          enum: ['resumed'],
+          type: 'string',
+        },
+      },
+      required: ['kind'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionChatEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1SessionChatPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['session'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionChatPayload: {
+      additionalProperties: false,
+      properties: {
+        chatId: {
+          type: 'string',
+        },
+        kind: {
+          enum: ['chat'],
+          type: 'string',
+        },
+      },
+      required: ['kind', 'chatId'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionKind: {
+      enum: ['trace', 'chat', 'title', 'start'],
+      type: 'string',
+    },
+    MothershipStreamV1SessionStartData: {
+      additionalProperties: false,
+      properties: {
+        responseId: {
+          type: 'string',
+        },
+      },
+      type: 'object',
+    },
+    MothershipStreamV1SessionStartEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1SessionStartPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['session'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionStartPayload: {
+      additionalProperties: false,
+      properties: {
+        data: {
+          $ref: '#/$defs/MothershipStreamV1SessionStartData',
+        },
+        kind: {
+          enum: ['start'],
+          type: 'string',
+        },
+      },
+      required: ['kind'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionTitleEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1SessionTitlePayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['session'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionTitlePayload: {
+      additionalProperties: false,
+      properties: {
+        kind: {
+          enum: ['title'],
+          type: 'string',
+        },
+        title: {
+          type: 'string',
+        },
+      },
+      required: ['kind', 'title'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionTraceEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1SessionTracePayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['session'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1SessionTracePayload: {
+      additionalProperties: false,
+      properties: {
+        kind: {
+          enum: ['trace'],
+          type: 'string',
+        },
+        requestId: {
+          type: 'string',
+        },
+        spanId: {
+          type: 'string',
+        },
+      },
+      required: ['kind', 'requestId'],
+      type: 'object',
+    },
+    MothershipStreamV1SpanKind: {
+      enum: ['subagent'],
+      type: 'string',
+    },
+    MothershipStreamV1SpanLifecycleEvent: {
+      enum: ['start', 'end'],
+      type: 'string',
+    },
+    MothershipStreamV1SpanPayloadKind: {
+      enum: ['subagent', 'structured_result', 'subagent_result'],
+      type: 'string',
+    },
+    MothershipStreamV1StreamCursor: {
+      additionalProperties: false,
+      properties: {
+        cursor: {
+          type: 'string',
+        },
+        seq: {
+          type: 'integer',
+        },
+        streamId: {
+          type: 'string',
+        },
+      },
+      required: ['streamId', 'cursor', 'seq'],
+      type: 'object',
+    },
+    MothershipStreamV1StreamRef: {
+      additionalProperties: false,
+      properties: {
+        chatId: {
+          type: 'string',
+        },
+        cursor: {
+          type: 'string',
+        },
+        streamId: {
+          type: 'string',
+        },
+      },
+      required: ['streamId'],
+      type: 'object',
+    },
+    MothershipStreamV1StreamScope: {
+      additionalProperties: false,
+      properties: {
+        agentId: {
+          type: 'string',
+        },
+        lane: {
+          enum: ['subagent'],
+          type: 'string',
+        },
+        parentToolCallId: {
+          type: 'string',
+        },
+      },
+      required: ['lane'],
+      type: 'object',
+    },
+    MothershipStreamV1StructuredResultSpanEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1StructuredResultSpanPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['span'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1StructuredResultSpanPayload: {
+      additionalProperties: false,
+      properties: {
+        agent: {
+          type: 'string',
+        },
+        data: true,
+        kind: {
+          enum: ['structured_result'],
+          type: 'string',
+        },
+      },
+      required: ['kind'],
+      type: 'object',
+    },
+    MothershipStreamV1SubagentResultSpanEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1SubagentResultSpanPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['span'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1SubagentResultSpanPayload: {
+      additionalProperties: false,
+      properties: {
+        agent: {
+          type: 'string',
+        },
+        data: true,
+        kind: {
+          enum: ['subagent_result'],
+          type: 'string',
+        },
+      },
+      required: ['kind'],
+      type: 'object',
+    },
+    MothershipStreamV1SubagentSpanEndEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1SubagentSpanEndPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['span'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1SubagentSpanEndPayload: {
+      additionalProperties: false,
+      properties: {
+        agent: {
+          type: 'string',
+        },
+        data: true,
+        event: {
+          enum: ['end'],
+          type: 'string',
+        },
+        kind: {
+          enum: ['subagent'],
+          type: 'string',
+        },
+      },
+      required: ['kind', 'event'],
+      type: 'object',
+    },
+    MothershipStreamV1SubagentSpanStartEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1SubagentSpanStartPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['span'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1SubagentSpanStartPayload: {
+      additionalProperties: false,
+      properties: {
+        agent: {
+          type: 'string',
+        },
+        data: true,
+        event: {
+          enum: ['start'],
+          type: 'string',
+        },
+        kind: {
+          enum: ['subagent'],
+          type: 'string',
+        },
+      },
+      required: ['kind', 'event'],
+      type: 'object',
+    },
+    MothershipStreamV1TextChannel: {
+      enum: ['assistant', 'thinking'],
+      type: 'string',
+    },
+    MothershipStreamV1TextEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1TextPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['text'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1TextPayload: {
+      additionalProperties: false,
+      properties: {
+        channel: {
+          $ref: '#/$defs/MothershipStreamV1TextChannel',
+        },
+        text: {
+          type: 'string',
+        },
+      },
+      required: ['channel', 'text'],
+      type: 'object',
+    },
+    MothershipStreamV1ToolArgsDeltaEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1ToolArgsDeltaPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['tool'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1ToolArgsDeltaPayload: {
+      additionalProperties: false,
+      properties: {
+        argumentsDelta: {
+          type: 'string',
+        },
+        executor: {
+          $ref: '#/$defs/MothershipStreamV1ToolExecutor',
+        },
+        mode: {
+          $ref: '#/$defs/MothershipStreamV1ToolMode',
+        },
+        phase: {
+          enum: ['args_delta'],
+          type: 'string',
+        },
+        toolCallId: {
+          type: 'string',
+        },
+        toolName: {
+          type: 'string',
+        },
+      },
+      required: ['toolCallId', 'toolName', 'argumentsDelta', 'executor', 'mode', 'phase'],
+      type: 'object',
+    },
+    MothershipStreamV1ToolCallDescriptor: {
+      additionalProperties: false,
+      properties: {
+        arguments: {
+          $ref: '#/$defs/MothershipStreamV1AdditionalPropertiesMap',
+        },
+        executor: {
+          $ref: '#/$defs/MothershipStreamV1ToolExecutor',
+        },
+        mode: {
+          $ref: '#/$defs/MothershipStreamV1ToolMode',
+        },
+        partial: {
+          type: 'boolean',
+        },
+        phase: {
+          enum: ['call'],
+          type: 'string',
+        },
+        requiresConfirmation: {
+          type: 'boolean',
+        },
+        status: {
+          $ref: '#/$defs/MothershipStreamV1ToolStatus',
+        },
+        toolCallId: {
+          type: 'string',
+        },
+        toolName: {
+          type: 'string',
+        },
+        ui: {
+          $ref: '#/$defs/MothershipStreamV1ToolUI',
+        },
+      },
+      required: ['toolCallId', 'toolName', 'executor', 'mode', 'phase'],
+      type: 'object',
+    },
+    MothershipStreamV1ToolCallEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1ToolCallDescriptor',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['tool'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1ToolExecutor: {
+      enum: ['go', 'sim', 'client'],
+      type: 'string',
+    },
+    MothershipStreamV1ToolMode: {
+      enum: ['sync', 'async'],
+      type: 'string',
+    },
+    MothershipStreamV1ToolOutcome: {
+      enum: ['success', 'error', 'cancelled', 'skipped', 'rejected'],
+      type: 'string',
+    },
+    MothershipStreamV1ToolPhase: {
+      enum: ['call', 'args_delta', 'result'],
+      type: 'string',
+    },
+    MothershipStreamV1ToolResultEventEnvelope: {
+      additionalProperties: false,
+      properties: {
+        payload: {
+          $ref: '#/$defs/MothershipStreamV1ToolResultPayload',
+        },
+        scope: {
+          $ref: '#/$defs/MothershipStreamV1StreamScope',
+        },
+        seq: {
+          type: 'integer',
+        },
+        stream: {
+          $ref: '#/$defs/MothershipStreamV1StreamRef',
+        },
+        trace: {
+          $ref: '#/$defs/MothershipStreamV1Trace',
+        },
+        ts: {
+          type: 'string',
+        },
+        type: {
+          enum: ['tool'],
+          type: 'string',
+        },
+        v: {
+          enum: [1],
+          type: 'integer',
+        },
+      },
+      required: ['v', 'seq', 'ts', 'stream', 'type', 'payload'],
+      type: 'object',
+    },
+    MothershipStreamV1ToolResultPayload: {
+      additionalProperties: false,
+      properties: {
+        error: {
+          type: 'string',
+        },
+        executor: {
+          $ref: '#/$defs/MothershipStreamV1ToolExecutor',
+        },
+        mode: {
+          $ref: '#/$defs/MothershipStreamV1ToolMode',
+        },
+        output: true,
+        phase: {
+          enum: ['result'],
+          type: 'string',
+        },
+        status: {
+          $ref: '#/$defs/MothershipStreamV1ToolStatus',
+        },
+        success: {
+          type: 'boolean',
+        },
+        toolCallId: {
+          type: 'string',
+        },
+        toolName: {
+          type: 'string',
+        },
+      },
+      required: ['toolCallId', 'toolName', 'executor', 'mode', 'phase', 'success'],
+      type: 'object',
+    },
+    MothershipStreamV1ToolStatus: {
+      enum: ['generating', 'executing', 'success', 'error', 'cancelled', 'skipped', 'rejected'],
+      type: 'string',
+    },
+    MothershipStreamV1ToolUI: {
+      additionalProperties: false,
+      properties: {
+        clientExecutable: {
+          type: 'boolean',
+        },
+        hidden: {
+          type: 'boolean',
+        },
+        icon: {
+          type: 'string',
+        },
+        internal: {
+          type: 'boolean',
+        },
+        phaseLabel: {
+          type: 'string',
+        },
+        requiresConfirmation: {
+          type: 'boolean',
+        },
+        title: {
+          type: 'string',
+        },
+      },
+      type: 'object',
+    },
+    MothershipStreamV1Trace: {
+      additionalProperties: false,
+      properties: {
+        requestId: {
+          type: 'string',
+        },
+        spanId: {
+          type: 'string',
+        },
+      },
+      required: ['requestId'],
+      type: 'object',
+    },
+    MothershipStreamV1UsageData: {
+      additionalProperties: false,
+      properties: {
+        cache_creation_input_tokens: {
+          type: 'integer',
+        },
+        cache_read_input_tokens: {
+          type: 'integer',
+        },
+        input_tokens: {
+          type: 'integer',
+        },
+        model: {
+          type: 'string',
+        },
+        output_tokens: {
+          type: 'integer',
+        },
+        total_tokens: {
+          type: 'integer',
+        },
+      },
+      type: 'object',
+    },
+  },
+  $id: 'mothership-stream-v1.schema.json',
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  description: 'Shared execution-oriented mothership stream contract from Go to Sim.',
+  oneOf: [
+    {
+      $ref: '#/$defs/MothershipStreamV1SessionStartEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1SessionChatEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1SessionTitleEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1SessionTraceEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1TextEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1ToolCallEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1ToolArgsDeltaEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1ToolResultEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1SubagentSpanStartEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1SubagentSpanEndEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1StructuredResultSpanEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1SubagentResultSpanEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1ResourceUpsertEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1ResourceRemoveEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1CheckpointPauseEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1RunResumedEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1CompactionStartEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1CompactionDoneEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1ErrorEventEnvelope',
+    },
+    {
+      $ref: '#/$defs/MothershipStreamV1CompleteEventEnvelope',
+    },
+  ],
+  title: 'MothershipStreamV1EventEnvelope',
+}
diff --git a/apps/sim/lib/copilot/generated/mothership-stream-v1.ts b/apps/sim/lib/copilot/generated/mothership-stream-v1.ts
new file mode 100644
index 00000000000..24841264e6c
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/mothership-stream-v1.ts
@@ -0,0 +1,553 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+//
+
+/**
+ * Shared execution-oriented mothership stream contract from Go to Sim.
+ */
+export type MothershipStreamV1EventEnvelope =
+  | MothershipStreamV1SessionStartEventEnvelope
+  | MothershipStreamV1SessionChatEventEnvelope
+  | MothershipStreamV1SessionTitleEventEnvelope
+  | MothershipStreamV1SessionTraceEventEnvelope
+  | MothershipStreamV1TextEventEnvelope
+  | MothershipStreamV1ToolCallEventEnvelope
+  | MothershipStreamV1ToolArgsDeltaEventEnvelope
+  | MothershipStreamV1ToolResultEventEnvelope
+  | MothershipStreamV1SubagentSpanStartEventEnvelope
+  | MothershipStreamV1SubagentSpanEndEventEnvelope
+  | MothershipStreamV1StructuredResultSpanEventEnvelope
+  | MothershipStreamV1SubagentResultSpanEventEnvelope
+  | MothershipStreamV1ResourceUpsertEventEnvelope
+  | MothershipStreamV1ResourceRemoveEventEnvelope
+  | MothershipStreamV1CheckpointPauseEventEnvelope
+  | MothershipStreamV1RunResumedEventEnvelope
+  | MothershipStreamV1CompactionStartEventEnvelope
+  | MothershipStreamV1CompactionDoneEventEnvelope
+  | MothershipStreamV1ErrorEventEnvelope
+  | MothershipStreamV1CompleteEventEnvelope
+export type MothershipStreamV1TextChannel = 'assistant' | 'thinking'
+export type MothershipStreamV1ToolExecutor = 'go' | 'sim' | 'client'
+export type MothershipStreamV1ToolMode = 'sync' | 'async'
+export type MothershipStreamV1ToolStatus =
+  | 'generating'
+  | 'executing'
+  | 'success'
+  | 'error'
+  | 'cancelled'
+  | 'skipped'
+  | 'rejected'
+export type MothershipStreamV1CompletionStatus = 'complete' | 'error' | 'cancelled'
+
+export interface MothershipStreamV1SessionStartEventEnvelope {
+  payload: MothershipStreamV1SessionStartPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'session'
+  v: 1
+}
+export interface MothershipStreamV1SessionStartPayload {
+  data?: MothershipStreamV1SessionStartData
+  kind: 'start'
+}
+export interface MothershipStreamV1SessionStartData {
+  responseId?: string
+}
+export interface MothershipStreamV1StreamScope {
+  agentId?: string
+  lane: 'subagent'
+  parentToolCallId?: string
+}
+export interface MothershipStreamV1StreamRef {
+  chatId?: string
+  cursor?: string
+  streamId: string
+}
+export interface MothershipStreamV1Trace {
+  requestId: string
+  spanId?: string
+}
+export interface MothershipStreamV1SessionChatEventEnvelope {
+  payload: MothershipStreamV1SessionChatPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'session'
+  v: 1
+}
+export interface MothershipStreamV1SessionChatPayload {
+  chatId: string
+  kind: 'chat'
+}
+export interface MothershipStreamV1SessionTitleEventEnvelope {
+  payload: MothershipStreamV1SessionTitlePayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'session'
+  v: 1
+}
+export interface MothershipStreamV1SessionTitlePayload {
+  kind: 'title'
+  title: string
+}
+export interface MothershipStreamV1SessionTraceEventEnvelope {
+  payload: MothershipStreamV1SessionTracePayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'session'
+  v: 1
+}
+export interface MothershipStreamV1SessionTracePayload {
+  kind: 'trace'
+  requestId: string
+  spanId?: string
+}
+export interface MothershipStreamV1TextEventEnvelope {
+  payload: MothershipStreamV1TextPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'text'
+  v: 1
+}
+export interface MothershipStreamV1TextPayload {
+  channel: MothershipStreamV1TextChannel
+  text: string
+}
+export interface MothershipStreamV1ToolCallEventEnvelope {
+  payload: MothershipStreamV1ToolCallDescriptor
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'tool'
+  v: 1
+}
+export interface MothershipStreamV1ToolCallDescriptor {
+  arguments?: MothershipStreamV1AdditionalPropertiesMap
+  executor: MothershipStreamV1ToolExecutor
+  mode: MothershipStreamV1ToolMode
+  partial?: boolean
+  phase: 'call'
+  requiresConfirmation?: boolean
+  status?: MothershipStreamV1ToolStatus
+  toolCallId: string
+  toolName: string
+  ui?: MothershipStreamV1ToolUI
+}
+export interface MothershipStreamV1AdditionalPropertiesMap {
+  [k: string]: unknown
+}
+export interface MothershipStreamV1ToolUI {
+  clientExecutable?: boolean
+  hidden?: boolean
+  icon?: string
+  internal?: boolean
+  phaseLabel?: string
+  requiresConfirmation?: boolean
+  title?: string
+}
+export interface MothershipStreamV1ToolArgsDeltaEventEnvelope {
+  payload: MothershipStreamV1ToolArgsDeltaPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'tool'
+  v: 1
+}
+export interface MothershipStreamV1ToolArgsDeltaPayload {
+  argumentsDelta: string
+  executor: MothershipStreamV1ToolExecutor
+  mode: MothershipStreamV1ToolMode
+  phase: 'args_delta'
+  toolCallId: string
+  toolName: string
+}
+export interface MothershipStreamV1ToolResultEventEnvelope {
+  payload: MothershipStreamV1ToolResultPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'tool'
+  v: 1
+}
+export interface MothershipStreamV1ToolResultPayload {
+  error?: string
+  executor: MothershipStreamV1ToolExecutor
+  mode: MothershipStreamV1ToolMode
+  output?: unknown
+  phase: 'result'
+  status?: MothershipStreamV1ToolStatus
+  success: boolean
+  toolCallId: string
+  toolName: string
+}
+export interface MothershipStreamV1SubagentSpanStartEventEnvelope {
+  payload: MothershipStreamV1SubagentSpanStartPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'span'
+  v: 1
+}
+export interface MothershipStreamV1SubagentSpanStartPayload {
+  agent?: string
+  data?: unknown
+  event: 'start'
+  kind: 'subagent'
+}
+export interface MothershipStreamV1SubagentSpanEndEventEnvelope {
+  payload: MothershipStreamV1SubagentSpanEndPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'span'
+  v: 1
+}
+export interface MothershipStreamV1SubagentSpanEndPayload {
+  agent?: string
+  data?: unknown
+  event: 'end'
+  kind: 'subagent'
+}
+export interface MothershipStreamV1StructuredResultSpanEventEnvelope {
+  payload: MothershipStreamV1StructuredResultSpanPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'span'
+  v: 1
+}
+export interface MothershipStreamV1StructuredResultSpanPayload {
+  agent?: string
+  data?: unknown
+  kind: 'structured_result'
+}
+export interface MothershipStreamV1SubagentResultSpanEventEnvelope {
+  payload: MothershipStreamV1SubagentResultSpanPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'span'
+  v: 1
+}
+export interface MothershipStreamV1SubagentResultSpanPayload {
+  agent?: string
+  data?: unknown
+  kind: 'subagent_result'
+}
+export interface MothershipStreamV1ResourceUpsertEventEnvelope {
+  payload: MothershipStreamV1ResourceUpsertPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'resource'
+  v: 1
+}
+export interface MothershipStreamV1ResourceUpsertPayload {
+  op: 'upsert'
+  resource: MothershipStreamV1ResourceDescriptor
+}
+export interface MothershipStreamV1ResourceDescriptor {
+  id: string
+  title?: string
+  type: string
+}
+export interface MothershipStreamV1ResourceRemoveEventEnvelope {
+  payload: MothershipStreamV1ResourceRemovePayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'resource'
+  v: 1
+}
+export interface MothershipStreamV1ResourceRemovePayload {
+  op: 'remove'
+  resource: MothershipStreamV1ResourceDescriptor
+}
+export interface MothershipStreamV1CheckpointPauseEventEnvelope {
+  payload: MothershipStreamV1CheckpointPausePayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'run'
+  v: 1
+}
+export interface MothershipStreamV1CheckpointPausePayload {
+  checkpointId: string
+  executionId: string
+  frames?: MothershipStreamV1CheckpointPauseFrame[]
+  kind: 'checkpoint_pause'
+  pendingToolCallIds: string[]
+  runId: string
+}
+export interface MothershipStreamV1CheckpointPauseFrame {
+  parentToolCallId: string
+  parentToolName: string
+  pendingToolIds: string[]
+}
+export interface MothershipStreamV1RunResumedEventEnvelope {
+  payload: MothershipStreamV1RunResumedPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'run'
+  v: 1
+}
+export interface MothershipStreamV1RunResumedPayload {
+  kind: 'resumed'
+}
+export interface MothershipStreamV1CompactionStartEventEnvelope {
+  payload: MothershipStreamV1CompactionStartPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'run'
+  v: 1
+}
+export interface MothershipStreamV1CompactionStartPayload {
+  kind: 'compaction_start'
+}
+export interface MothershipStreamV1CompactionDoneEventEnvelope {
+  payload: MothershipStreamV1CompactionDonePayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'run'
+  v: 1
+}
+export interface MothershipStreamV1CompactionDonePayload {
+  data?: MothershipStreamV1CompactionDoneData
+  kind: 'compaction_done'
+}
+export interface MothershipStreamV1CompactionDoneData {
+  summary_chars: number
+}
+export interface MothershipStreamV1ErrorEventEnvelope {
+  payload: MothershipStreamV1ErrorPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'error'
+  v: 1
+}
+export interface MothershipStreamV1ErrorPayload {
+  code?: string
+  data?: unknown
+  displayMessage?: string
+  error?: string
+  message: string
+  provider?: string
+}
+export interface MothershipStreamV1CompleteEventEnvelope {
+  payload: MothershipStreamV1CompletePayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'complete'
+  v: 1
+}
+export interface MothershipStreamV1CompletePayload {
+  cost?: MothershipStreamV1CostData
+  reason?: string
+  response?: unknown
+  status: MothershipStreamV1CompletionStatus
+  usage?: MothershipStreamV1UsageData
+}
+export interface MothershipStreamV1CostData {
+  input?: number
+  output?: number
+  total?: number
+}
+export interface MothershipStreamV1UsageData {
+  cache_creation_input_tokens?: number
+  cache_read_input_tokens?: number
+  input_tokens?: number
+  model?: string
+  output_tokens?: number
+  total_tokens?: number
+}
+
+export type MothershipStreamV1AsyncToolRecordStatus =
+  | 'pending'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'delivered'
+
+export const MothershipStreamV1AsyncToolRecordStatus = {
+  pending: 'pending',
+  running: 'running',
+  completed: 'completed',
+  failed: 'failed',
+  cancelled: 'cancelled',
+  delivered: 'delivered',
+} as const
+
+export const MothershipStreamV1CompletionStatus = {
+  complete: 'complete',
+  error: 'error',
+  cancelled: 'cancelled',
+} as const
+
+export type MothershipStreamV1EventType =
+  | 'session'
+  | 'text'
+  | 'tool'
+  | 'span'
+  | 'resource'
+  | 'run'
+  | 'error'
+  | 'complete'
+
+export const MothershipStreamV1EventType = {
+  session: 'session',
+  text: 'text',
+  tool: 'tool',
+  span: 'span',
+  resource: 'resource',
+  run: 'run',
+  error: 'error',
+  complete: 'complete',
+} as const
+
+export type MothershipStreamV1ResourceOp = 'upsert' | 'remove'
+
+export const MothershipStreamV1ResourceOp = {
+  upsert: 'upsert',
+  remove: 'remove',
+} as const
+
+export type MothershipStreamV1RunKind =
+  | 'checkpoint_pause'
+  | 'resumed'
+  | 'compaction_start'
+  | 'compaction_done'
+
+export const MothershipStreamV1RunKind = {
+  checkpoint_pause: 'checkpoint_pause',
+  resumed: 'resumed',
+  compaction_start: 'compaction_start',
+  compaction_done: 'compaction_done',
+} as const
+
+export type MothershipStreamV1SessionKind = 'trace' | 'chat' | 'title' | 'start'
+
+export const MothershipStreamV1SessionKind = {
+  trace: 'trace',
+  chat: 'chat',
+  title: 'title',
+  start: 'start',
+} as const
+
+export type MothershipStreamV1SpanKind = 'subagent'
+
+export const MothershipStreamV1SpanKind = {
+  subagent: 'subagent',
+} as const
+
+export type MothershipStreamV1SpanLifecycleEvent = 'start' | 'end'
+
+export const MothershipStreamV1SpanLifecycleEvent = {
+  start: 'start',
+  end: 'end',
+} as const
+
+export type MothershipStreamV1SpanPayloadKind = 'subagent' | 'structured_result' | 'subagent_result'
+
+export const MothershipStreamV1SpanPayloadKind = {
+  subagent: 'subagent',
+  structured_result: 'structured_result',
+  subagent_result: 'subagent_result',
+} as const
+
+export const MothershipStreamV1TextChannel = {
+  assistant: 'assistant',
+  thinking: 'thinking',
+} as const
+
+export const MothershipStreamV1ToolExecutor = {
+  go: 'go',
+  sim: 'sim',
+  client: 'client',
+} as const
+
+export const MothershipStreamV1ToolMode = {
+  sync: 'sync',
+  async: 'async',
+} as const
+
+export type MothershipStreamV1ToolOutcome =
+  | 'success'
+  | 'error'
+  | 'cancelled'
+  | 'skipped'
+  | 'rejected'
+
+export const MothershipStreamV1ToolOutcome = {
+  success: 'success',
+  error: 'error',
+  cancelled: 'cancelled',
+  skipped: 'skipped',
+  rejected: 'rejected',
+} as const
+
+export type MothershipStreamV1ToolPhase = 'call' | 'args_delta' | 'result'
+
+export const MothershipStreamV1ToolPhase = {
+  call: 'call',
+  args_delta: 'args_delta',
+  result: 'result',
+} as const
+
+export const MothershipStreamV1ToolStatus = {
+  generating: 'generating',
+  executing: 'executing',
+  success: 'success',
+  error: 'error',
+  cancelled: 'cancelled',
+  skipped: 'skipped',
+  rejected: 'rejected',
+} as const
diff --git a/apps/sim/lib/copilot/generated/request-trace-v1.ts b/apps/sim/lib/copilot/generated/request-trace-v1.ts
new file mode 100644
index 00000000000..f8d2bd06e01
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/request-trace-v1.ts
@@ -0,0 +1,133 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+//
+
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1Outcome".
+ */
+export type RequestTraceV1Outcome = 'success' | 'error' | 'cancelled'
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1SpanSource".
+ */
+export type RequestTraceV1SpanSource = 'sim' | 'go'
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1SpanStatus".
+ */
+export type RequestTraceV1SpanStatus = 'ok' | 'error' | 'cancelled' | 'pending'
+
+/**
+ * Trace report sent from Sim to Go after a request completes.
+ */
+export interface RequestTraceV1SimReport {
+  chatId?: string
+  cost?: RequestTraceV1CostSummary
+  durationMs: number
+  endMs: number
+  executionId?: string
+  goTraceId?: string
+  outcome: RequestTraceV1Outcome
+  runId?: string
+  simRequestId: string
+  spans: RequestTraceV1Span[]
+  startMs: number
+  streamId?: string
+  usage?: RequestTraceV1UsageSummary
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1CostSummary".
+ */
+export interface RequestTraceV1CostSummary {
+  billedTotalCost?: number
+  rawTotalCost?: number
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1Span".
+ */
+export interface RequestTraceV1Span {
+  attributes?: MothershipStreamV1AdditionalPropertiesMap
+  durationMs: number
+  endMs: number
+  kind?: string
+  name: string
+  parentName?: string
+  source?: RequestTraceV1SpanSource
+  startMs: number
+  status: RequestTraceV1SpanStatus
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "MothershipStreamV1AdditionalPropertiesMap".
+ */
+export interface MothershipStreamV1AdditionalPropertiesMap {
+  [k: string]: unknown
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1UsageSummary".
+ */
+export interface RequestTraceV1UsageSummary {
+  cacheReadTokens?: number
+  cacheWriteTokens?: number
+  inputTokens?: number
+  outputTokens?: number
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1MergedTrace".
+ */
+export interface RequestTraceV1MergedTrace {
+  chatId?: string
+  cost?: RequestTraceV1CostSummary
+  durationMs: number
+  endMs: number
+  goTraceId: string
+  outcome: RequestTraceV1Outcome
+  serviceCharges?: MothershipStreamV1AdditionalPropertiesMap
+  simRequestId?: string
+  spans: RequestTraceV1Span[]
+  startMs: number
+  streamId?: string
+  usage?: RequestTraceV1UsageSummary
+  userId?: string
+}
+/**
+ * This interface was referenced by `RequestTraceV1SimReport`'s JSON-Schema
+ * via the `definition` "RequestTraceV1SimReport".
+ */
+export interface RequestTraceV1SimReport1 {
+  chatId?: string
+  cost?: RequestTraceV1CostSummary
+  durationMs: number
+  endMs: number
+  executionId?: string
+  goTraceId?: string
+  outcome: RequestTraceV1Outcome
+  runId?: string
+  simRequestId: string
+  spans: RequestTraceV1Span[]
+  startMs: number
+  streamId?: string
+  usage?: RequestTraceV1UsageSummary
+}
+
+export const RequestTraceV1Outcome = {
+  success: 'success',
+  error: 'error',
+  cancelled: 'cancelled',
+} as const
+
+export const RequestTraceV1SpanSource = {
+  sim: 'sim',
+  go: 'go',
+} as const
+
+export const RequestTraceV1SpanStatus = {
+  ok: 'ok',
+  error: 'error',
+  cancelled: 'cancelled',
+  pending: 'pending',
+} as const
diff --git a/apps/sim/lib/copilot/generated/tool-catalog-v1.ts b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
new file mode 100644
index 00000000000..44986aa8b04
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
@@ -0,0 +1,3334 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+// Generated from copilot/contracts/tool-catalog-v1.json
+//
+
+export interface ToolCatalogEntry {
+  clientExecutable?: boolean
+  hidden?: boolean
+  id:
+    | 'agent'
+    | 'auth'
+    | 'check_deployment_status'
+    | 'complete_job'
+    | 'context_write'
+    | 'crawl_website'
+    | 'create_file'
+    | 'create_folder'
+    | 'create_job'
+    | 'create_workflow'
+    | 'create_workspace_mcp_server'
+    | 'delete_file'
+    | 'delete_folder'
+    | 'delete_workflow'
+    | 'delete_workspace_mcp_server'
+    | 'deploy'
+    | 'deploy_api'
+    | 'deploy_chat'
+    | 'deploy_mcp'
+    | 'download_to_workspace_file'
+    | 'edit_content'
+    | 'edit_workflow'
+    | 'file'
+    | 'function_execute'
+    | 'generate_api_key'
+    | 'generate_image'
+    | 'generate_visualization'
+    | 'get_block_outputs'
+    | 'get_block_upstream_references'
+    | 'get_deployed_workflow_state'
+    | 'get_deployment_version'
+    | 'get_execution_summary'
+    | 'get_job_logs'
+    | 'get_page_contents'
+    | 'get_platform_actions'
+    | 'get_workflow_data'
+    | 'get_workflow_logs'
+    | 'glob'
+    | 'grep'
+    | 'job'
+    | 'knowledge'
+    | 'knowledge_base'
+    | 'list_folders'
+    | 'list_user_workspaces'
+    | 'list_workspace_mcp_servers'
+    | 'manage_credential'
+    | 'manage_custom_tool'
+    | 'manage_job'
+    | 'manage_mcp_tool'
+    | 'manage_skill'
+    | 'materialize_file'
+    | 'move_folder'
+    | 'move_workflow'
+    | 'oauth_get_auth_link'
+    | 'oauth_request_access'
+    | 'open_resource'
+    | 'read'
+    | 'redeploy'
+    | 'rename_file'
+    | 'rename_workflow'
+    | 'research'
+    | 'respond'
+    | 'restore_resource'
+    | 'revert_to_version'
+    | 'run_block'
+    | 'run_from_block'
+    | 'run_workflow'
+    | 'run_workflow_until_block'
+    | 'scrape_page'
+    | 'search_documentation'
+    | 'search_library_docs'
+    | 'search_online'
+    | 'search_patterns'
+    | 'set_block_enabled'
+    | 'set_environment_variables'
+    | 'set_global_workflow_variables'
+    | 'superagent'
+    | 'table'
+    | 'tool_search_tool_regex'
+    | 'update_job_history'
+    | 'update_workspace_mcp_server'
+    | 'user_memory'
+    | 'user_table'
+    | 'workflow'
+    | 'workspace_file'
+  internal?: boolean
+  mode: 'async' | 'sync'
+  name:
+    | 'agent'
+    | 'auth'
+    | 'check_deployment_status'
+    | 'complete_job'
+    | 'context_write'
+    | 'crawl_website'
+    | 'create_file'
+    | 'create_folder'
+    | 'create_job'
+    | 'create_workflow'
+    | 'create_workspace_mcp_server'
+    | 'delete_file'
+    | 'delete_folder'
+    | 'delete_workflow'
+    | 'delete_workspace_mcp_server'
+    | 'deploy'
+    | 'deploy_api'
+    | 'deploy_chat'
+    | 'deploy_mcp'
+    | 'download_to_workspace_file'
+    | 'edit_content'
+    | 'edit_workflow'
+    | 'file'
+    | 'function_execute'
+    | 'generate_api_key'
+    | 'generate_image'
+    | 'generate_visualization'
+    | 'get_block_outputs'
+    | 'get_block_upstream_references'
+    | 'get_deployed_workflow_state'
+    | 'get_deployment_version'
+    | 'get_execution_summary'
+    | 'get_job_logs'
+    | 'get_page_contents'
+    | 'get_platform_actions'
+    | 'get_workflow_data'
+    | 'get_workflow_logs'
+    | 'glob'
+    | 'grep'
+    | 'job'
+    | 'knowledge'
+    | 'knowledge_base'
+    | 'list_folders'
+    | 'list_user_workspaces'
+    | 'list_workspace_mcp_servers'
+    | 'manage_credential'
+    | 'manage_custom_tool'
+    | 'manage_job'
+    | 'manage_mcp_tool'
+    | 'manage_skill'
+    | 'materialize_file'
+    | 'move_folder'
+    | 'move_workflow'
+    | 'oauth_get_auth_link'
+    | 'oauth_request_access'
+    | 'open_resource'
+    | 'read'
+    | 'redeploy'
+    | 'rename_file'
+    | 'rename_workflow'
+    | 'research'
+    | 'respond'
+    | 'restore_resource'
+    | 'revert_to_version'
+    | 'run_block'
+    | 'run_from_block'
+    | 'run_workflow'
+    | 'run_workflow_until_block'
+    | 'scrape_page'
+    | 'search_documentation'
+    | 'search_library_docs'
+    | 'search_online'
+    | 'search_patterns'
+    | 'set_block_enabled'
+    | 'set_environment_variables'
+    | 'set_global_workflow_variables'
+    | 'superagent'
+    | 'table'
+    | 'tool_search_tool_regex'
+    | 'update_job_history'
+    | 'update_workspace_mcp_server'
+    | 'user_memory'
+    | 'user_table'
+    | 'workflow'
+    | 'workspace_file'
+  parameters: unknown
+  requiredPermission?: 'admin' | 'write'
+  requiresConfirmation?: boolean
+  resultSchema?: unknown
+  route: 'client' | 'go' | 'sim' | 'subagent'
+  subagentId?:
+    | 'agent'
+    | 'auth'
+    | 'deploy'
+    | 'file'
+    | 'job'
+    | 'knowledge'
+    | 'research'
+    | 'superagent'
+    | 'table'
+    | 'workflow'
+}
+
+export const Agent: ToolCatalogEntry = {
+  id: 'agent',
+  name: 'agent',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: { description: 'What tool/skill/MCP action is needed.', type: 'string' },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'agent',
+  internal: true,
+  requiredPermission: 'write',
+}
+
+export const Auth: ToolCatalogEntry = {
+  id: 'auth',
+  name: 'auth',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: { description: 'What authentication/credential action is needed.', type: 'string' },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'auth',
+  internal: true,
+}
+
+export const CheckDeploymentStatus: ToolCatalogEntry = {
+  id: 'check_deployment_status',
+  name: 'check_deployment_status',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to check (defaults to current workflow)',
+      },
+    },
+  },
+}
+
+export const CompleteJob: ToolCatalogEntry = {
+  id: 'complete_job',
+  name: 'complete_job',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      jobId: { type: 'string', description: 'The ID of the job to mark as completed.' },
+    },
+    required: ['jobId'],
+  },
+}
+
+export const ContextWrite: ToolCatalogEntry = {
+  id: 'context_write',
+  name: 'context_write',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'Full content to write to the file (replaces existing content)',
+      },
+      file_path: { type: 'string', description: "Path of the file to write (e.g. 'SESSION.md')" },
+    },
+    required: ['file_path', 'content'],
+  },
+}
+
+export const CrawlWebsite: ToolCatalogEntry = {
+  id: 'crawl_website',
+  name: 'crawl_website',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      exclude_paths: {
+        type: 'array',
+        description: 'Skip URLs matching these patterns',
+        items: { type: 'string' },
+      },
+      include_paths: {
+        type: 'array',
+        description: 'Only crawl URLs matching these patterns',
+        items: { type: 'string' },
+      },
+      limit: { type: 'number', description: 'Maximum pages to crawl (default 10, max 50)' },
+      max_depth: { type: 'number', description: 'How deep to follow links (default 2)' },
+      url: { type: 'string', description: 'Starting URL to crawl from' },
+    },
+    required: ['url'],
+  },
+}
+
+export const CreateFile: ToolCatalogEntry = {
+  id: 'create_file',
+  name: 'create_file',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      contentType: {
+        type: 'string',
+        description:
+          'Optional MIME type override. Usually omit and let the system infer from the file extension.',
+      },
+      fileName: {
+        type: 'string',
+        description:
+          'Plain workspace filename including extension, e.g. "main.py" or "report.md". Must not contain slashes.',
+      },
+    },
+    required: ['fileName'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Contains id (the fileId) and name.' },
+      message: { type: 'string', description: 'Human-readable outcome.' },
+      success: { type: 'boolean', description: 'Whether the file was created.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiredPermission: 'write',
+}
+
+export const CreateFolder: ToolCatalogEntry = {
+  id: 'create_folder',
+  name: 'create_folder',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Folder name.' },
+      parentId: { type: 'string', description: 'Optional parent folder ID.' },
+      workspaceId: { type: 'string', description: 'Optional workspace ID.' },
+    },
+    required: ['name'],
+  },
+  requiredPermission: 'write',
+}
+
+export const CreateJob: ToolCatalogEntry = {
+  id: 'create_job',
+  name: 'create_job',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      cron: {
+        type: 'string',
+        description:
+          "Cron expression for recurring jobs (e.g., '*/5 * * * *' for every 5 minutes, '0 9 * * *' for daily at 9 AM). Omit for one-time jobs.",
+      },
+      lifecycle: {
+        type: 'string',
+        description:
+          "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called after the success condition is met.",
+        enum: ['persistent', 'until_complete'],
+      },
+      maxRuns: {
+        type: 'integer',
+        description:
+          'Maximum number of executions before the job auto-completes. Safety limit to prevent runaway polling.',
+      },
+      prompt: {
+        type: 'string',
+        description:
+          'The prompt to execute when the job fires. This is sent to the Mothership as a user message.',
+      },
+      successCondition: {
+        type: 'string',
+        description:
+          "What must happen for the job to be considered complete. Used with until_complete lifecycle (e.g., 'John has replied to the partnership email').",
+      },
+      time: {
+        type: 'string',
+        description:
+          "ISO 8601 datetime for one-time execution or as the start time for a cron schedule (e.g., '2026-03-06T09:00:00'). Include timezone offset or use the timezone parameter.",
+      },
+      timezone: {
+        type: 'string',
+        description:
+          "IANA timezone for the schedule (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC.",
+      },
+      title: {
+        type: 'string',
+        description:
+          "A short, descriptive title for the job (e.g., 'Email Poller', 'Daily Report'). Used as the display name.",
+      },
+    },
+    required: ['title', 'prompt'],
+  },
+}
+
+export const CreateWorkflow: ToolCatalogEntry = {
+  id: 'create_workflow',
+  name: 'create_workflow',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      description: { type: 'string', description: 'Optional workflow description.' },
+      folderId: { type: 'string', description: 'Optional folder ID.' },
+      name: { type: 'string', description: 'Workflow name.' },
+      workspaceId: { type: 'string', description: 'Optional workspace ID.' },
+    },
+    required: ['name'],
+  },
+  requiredPermission: 'write',
+}
+
+export const CreateWorkspaceMcpServer: ToolCatalogEntry = {
+  id: 'create_workspace_mcp_server',
+  name: 'create_workspace_mcp_server',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      description: { type: 'string', description: 'Optional description for the server' },
+      name: { type: 'string', description: 'Required: server name' },
+      workspaceId: { type: 'string', description: 'Workspace ID (defaults to current workspace)' },
+    },
+    required: ['name'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const DeleteFile: ToolCatalogEntry = {
+  id: 'delete_file',
+  name: 'delete_file',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      fileIds: {
+        type: 'array',
+        description: 'Canonical workspace file IDs of the files to delete.',
+        items: { type: 'string' },
+      },
+    },
+    required: ['fileIds'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      message: { type: 'string', description: 'Human-readable outcome.' },
+      success: { type: 'boolean', description: 'Whether the delete succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiredPermission: 'write',
+}
+
+export const DeleteFolder: ToolCatalogEntry = {
+  id: 'delete_folder',
+  name: 'delete_folder',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      folderIds: {
+        type: 'array',
+        description: 'The folder IDs to delete.',
+        items: { type: 'string' },
+      },
+    },
+    required: ['folderIds'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const DeleteWorkflow: ToolCatalogEntry = {
+  id: 'delete_workflow',
+  name: 'delete_workflow',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workflowIds: {
+        type: 'array',
+        description: 'The workflow IDs to delete.',
+        items: { type: 'string' },
+      },
+    },
+    required: ['workflowIds'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const DeleteWorkspaceMcpServer: ToolCatalogEntry = {
+  id: 'delete_workspace_mcp_server',
+  name: 'delete_workspace_mcp_server',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      serverId: { type: 'string', description: 'Required: the MCP server ID to delete' },
+    },
+    required: ['serverId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const Deploy: ToolCatalogEntry = {
+  id: 'deploy',
+  name: 'deploy',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: {
+        description:
+          'Detailed deployment instructions. Include deployment type (api/chat) and ALL user-specified options: identifier, title, description, authType, password, allowedEmails, welcomeMessage, outputConfigs (block outputs to display).',
+        type: 'string',
+      },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'deploy',
+  internal: true,
+}
+
+export const DeployApi: ToolCatalogEntry = {
+  id: 'deploy_api',
+  name: 'deploy_api',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Whether to deploy or undeploy the API endpoint',
+        enum: ['deploy', 'undeploy'],
+        default: 'deploy',
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to deploy (required in workspace context)',
+      },
+    },
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      apiEndpoint: { type: 'string', description: 'Canonical workflow execution endpoint.' },
+      baseUrl: { type: 'string', description: 'Base URL used to construct deployment URLs.' },
+      deployedAt: {
+        type: 'string',
+        description: 'Deployment timestamp when the workflow is deployed.',
+      },
+      deploymentConfig: {
+        type: 'object',
+        description:
+          'Structured deployment configuration keyed by surface name. For API deploys this includes endpoint, auth, and sync/stream/async mode details.',
+      },
+      deploymentStatus: {
+        type: 'object',
+        description: 'Structured per-surface deployment status keyed by surface name, such as api.',
+      },
+      deploymentType: {
+        type: 'string',
+        description:
+          'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+      },
+      examples: {
+        type: 'object',
+        description:
+          'Invocation examples keyed by surface name. For API deploys this includes curl examples for sync, stream, async, and polling.',
+      },
+      isDeployed: {
+        type: 'boolean',
+        description: 'Whether the workflow API is currently deployed after this tool call.',
+      },
+      version: {
+        type: 'number',
+        description: 'Deployment version for the current API deployment.',
+      },
+      workflowId: { type: 'string', description: 'Workflow ID that was deployed or undeployed.' },
+    },
+    required: [
+      'workflowId',
+      'isDeployed',
+      'deploymentType',
+      'deploymentStatus',
+      'deploymentConfig',
+      'examples',
+    ],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const DeployChat: ToolCatalogEntry = {
+  id: 'deploy_chat',
+  name: 'deploy_chat',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Whether to deploy or undeploy the chat interface',
+        enum: ['deploy', 'undeploy'],
+        default: 'deploy',
+      },
+      allowedEmails: {
+        type: 'array',
+        description: 'List of allowed emails/domains for email or SSO auth',
+        items: { type: 'string' },
+      },
+      authType: {
+        type: 'string',
+        description: 'Authentication type: public, password, email, or sso',
+        enum: ['public', 'password', 'email', 'sso'],
+        default: 'public',
+      },
+      description: { type: 'string', description: 'Optional description for the chat' },
+      identifier: {
+        type: 'string',
+        description: 'URL slug for the chat (lowercase letters, numbers, hyphens only)',
+      },
+      outputConfigs: {
+        type: 'array',
+        description: 'Output configurations specifying which block outputs to display in chat',
+        items: {
+          type: 'object',
+          properties: {
+            blockId: { type: 'string', description: 'The block UUID' },
+            path: {
+              type: 'string',
+              description: "The output path (e.g. 'response', 'response.content')",
+            },
+          },
+          required: ['blockId', 'path'],
+        },
+      },
+      password: { type: 'string', description: 'Password for password-protected chats' },
+      title: { type: 'string', description: 'Display title for the chat interface' },
+      welcomeMessage: { type: 'string', description: 'Welcome message shown to users' },
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to deploy (required in workspace context)',
+      },
+    },
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Action performed by the tool, such as "deploy" or "undeploy".',
+      },
+      apiEndpoint: {
+        type: 'string',
+        description: 'Paired workflow execution endpoint used by the chat deployment.',
+      },
+      baseUrl: { type: 'string', description: 'Base URL used to construct deployment URLs.' },
+      chatUrl: {
+        type: 'string',
+        description: 'Shareable chat URL when the chat surface is deployed.',
+      },
+      deployedAt: {
+        type: 'string',
+        description: 'Deployment timestamp for the underlying workflow deployment.',
+      },
+      deploymentConfig: {
+        type: 'object',
+        description:
+          'Structured deployment configuration keyed by surface name. Includes chat settings and the paired API invocation configuration.',
+      },
+      deploymentStatus: {
+        type: 'object',
+        description:
+          'Structured per-surface deployment status keyed by surface name, including api and chat.',
+      },
+      deploymentType: {
+        type: 'string',
+        description:
+          'Deployment surface this result describes. For deploy_chat this is always "chat".',
+      },
+      examples: {
+        type: 'object',
+        description:
+          'Invocation examples keyed by surface name. Includes chat access details and API curl examples.',
+      },
+      identifier: { type: 'string', description: 'Chat identifier or slug.' },
+      isChatDeployed: {
+        type: 'boolean',
+        description: 'Whether the chat surface is deployed after this tool call.',
+      },
+      isDeployed: {
+        type: 'boolean',
+        description: 'Whether the paired API surface remains deployed after this tool call.',
+      },
+      success: {
+        type: 'boolean',
+        description: 'Whether the deploy_chat action completed successfully.',
+      },
+      version: {
+        type: 'number',
+        description: 'Deployment version for the underlying workflow deployment.',
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID associated with the chat deployment.',
+      },
+    },
+    required: [
+      'workflowId',
+      'success',
+      'action',
+      'isDeployed',
+      'isChatDeployed',
+      'deploymentType',
+      'deploymentStatus',
+      'deploymentConfig',
+      'examples',
+    ],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const DeployMcp: ToolCatalogEntry = {
+  id: 'deploy_mcp',
+  name: 'deploy_mcp',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      parameterDescriptions: {
+        type: 'array',
+        description: 'Array of parameter descriptions for the tool',
+        items: {
+          type: 'object',
+          properties: {
+            description: { type: 'string', description: 'Parameter description' },
+            name: { type: 'string', description: 'Parameter name' },
+          },
+          required: ['name', 'description'],
+        },
+      },
+      serverId: {
+        type: 'string',
+        description: 'Required: server ID from list_workspace_mcp_servers',
+      },
+      toolDescription: { type: 'string', description: 'Description for the MCP tool' },
+      toolName: {
+        type: 'string',
+        description: 'Name for the MCP tool (defaults to workflow name)',
+      },
+      workflowId: { type: 'string', description: 'Workflow ID (defaults to active workflow)' },
+    },
+    required: ['serverId'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Action performed by the tool, such as "deploy" or "undeploy".',
+      },
+      apiEndpoint: {
+        type: 'string',
+        description: 'Underlying workflow API endpoint associated with the MCP tool.',
+      },
+      baseUrl: { type: 'string', description: 'Base URL used to construct deployment URLs.' },
+      deploymentConfig: {
+        type: 'object',
+        description:
+          'Structured deployment configuration keyed by surface name. Includes MCP server, tool, auth, and parameter schema details.',
+      },
+      deploymentStatus: {
+        type: 'object',
+        description:
+          'Structured per-surface deployment status keyed by surface name, including mcp and the underlying api surface when applicable.',
+      },
+      deploymentType: {
+        type: 'string',
+        description:
+          'Deployment surface this result describes. For deploy_mcp this is always "mcp".',
+      },
+      examples: {
+        type: 'object',
+        description:
+          'Setup examples keyed by surface name. Includes ready-to-paste config snippets for supported MCP clients.',
+      },
+      mcpServerUrl: { type: 'string', description: 'HTTP MCP server URL to configure in clients.' },
+      removed: {
+        type: 'boolean',
+        description: 'Whether the MCP deployment was removed during an undeploy action.',
+      },
+      serverId: { type: 'string', description: 'Workspace MCP server ID.' },
+      serverName: { type: 'string', description: 'Workspace MCP server name.' },
+      toolDescription: {
+        type: 'string',
+        description: 'MCP tool description exposed on the server.',
+      },
+      toolId: { type: 'string', description: 'MCP tool ID when deployed.' },
+      toolName: { type: 'string', description: 'MCP tool name exposed on the server.' },
+      updated: {
+        type: 'boolean',
+        description: 'Whether an existing MCP tool deployment was updated instead of created.',
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID associated with the MCP deployment.',
+      },
+    },
+    required: ['deploymentType', 'deploymentStatus'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const DownloadToWorkspaceFile: ToolCatalogEntry = {
+  id: 'download_to_workspace_file',
+  name: 'download_to_workspace_file',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      fileName: {
+        type: 'string',
+        description:
+          'Optional workspace file name to save as. If omitted, the name is inferred from the response or URL.',
+      },
+      url: {
+        type: 'string',
+        description:
+          'Direct URL of the file to download, such as an image CDN URL ending in .png or .jpg',
+      },
+    },
+    required: ['url'],
+  },
+  requiredPermission: 'write',
+}
+
+export const EditContent: ToolCatalogEntry = {
+  id: 'edit_content',
+  name: 'edit_content',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description:
+          'The text content to write. For append: text to append. For update: full replacement text. For patch with search_replace: the replacement text. For patch with anchored: the insert/replacement text.',
+      },
+    },
+    required: ['content'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: {
+        type: 'object',
+        description:
+          'Optional operation metadata such as file id, file name, size, and content type.',
+      },
+      message: { type: 'string', description: 'Human-readable summary of the outcome.' },
+      success: { type: 'boolean', description: 'Whether the content was applied successfully.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiredPermission: 'write',
+}
+
+export const EditWorkflow: ToolCatalogEntry = {
+  id: 'edit_workflow',
+  name: 'edit_workflow',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      operations: {
+        type: 'array',
+        description: 'Array of edit operations',
+        items: {
+          type: 'object',
+          properties: {
+            block_id: {
+              type: 'string',
+              description:
+                'Block ID for the operation. For add operations, this will be the desired ID for the new block.',
+            },
+            operation_type: {
+              type: 'string',
+              description: 'Type of operation to perform',
+              enum: ['add', 'edit', 'delete', 'insert_into_subflow', 'extract_from_subflow'],
+            },
+            params: {
+              type: 'object',
+              description:
+                'Parameters for the operation. \nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "gpt-4o"}}\nFor delete: {} (empty object)',
+            },
+          },
+          required: ['operation_type', 'block_id', 'params'],
+        },
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to edit. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['operations'],
+  },
+  requiredPermission: 'write',
+}
+
+export const File: ToolCatalogEntry = {
+  id: 'file',
+  name: 'file',
+  route: 'subagent',
+  mode: 'async',
+  parameters: { type: 'object' },
+  subagentId: 'file',
+  internal: true,
+}
+
+export const FunctionExecute: ToolCatalogEntry = {
+  id: 'function_execute',
+  name: 'function_execute',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description:
+          'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with access to pre-installed CLI tools and workspace env vars as $VAR_NAME.',
+      },
+      inputFiles: {
+        type: 'array',
+        description:
+          'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}. Example: ["wf_123"]',
+        items: { type: 'string' },
+      },
+      inputTables: {
+        type: 'array',
+        description:
+          'Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Example: ["tbl_abc123"]',
+        items: { type: 'string' },
+      },
+      language: {
+        type: 'string',
+        description: 'Execution language.',
+        enum: ['javascript', 'python', 'shell'],
+      },
+      outputFormat: {
+        type: 'string',
+        description:
+          'Format for outputPath. Determines how the code result is serialized. If omitted, inferred from outputPath file extension.',
+        enum: ['json', 'csv', 'txt', 'md', 'html'],
+      },
+      outputMimeType: {
+        type: 'string',
+        description:
+          'MIME type for outputSandboxPath export. Required for binary files: image/png, image/jpeg, application/pdf, etc. Omit for text files.',
+      },
+      outputPath: {
+        type: 'string',
+        description:
+          'Pipe output directly to a NEW workspace file instead of returning in context. ALWAYS use this instead of a separate workspace_file write call. Use a flat path like "files/result.json" — nested paths are not supported.',
+      },
+      outputSandboxPath: {
+        type: 'string',
+        description:
+          'Path to a file created inside the sandbox that should be exported to the workspace. Use together with outputPath.',
+      },
+      outputTable: {
+        type: 'string',
+        description:
+          'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
+      },
+    },
+    required: ['code'],
+  },
+  requiredPermission: 'write',
+}
+
+export const GenerateApiKey: ToolCatalogEntry = {
+  id: 'generate_api_key',
+  name: 'generate_api_key',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        description: "A descriptive name for the API key (e.g., 'production-key', 'dev-testing').",
+      },
+      workspaceId: {
+        type: 'string',
+        description: "Optional workspace ID. Defaults to user's default workspace.",
+      },
+    },
+    required: ['name'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const GenerateImage: ToolCatalogEntry = {
+  id: 'generate_image',
+  name: 'generate_image',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      aspectRatio: {
+        type: 'string',
+        description: 'Aspect ratio for the generated image.',
+        enum: ['1:1', '16:9', '9:16', '4:3', '3:4'],
+      },
+      fileName: {
+        type: 'string',
+        description:
+          'Output file name. Defaults to "generated-image.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+      },
+      overwriteFileId: {
+        type: 'string',
+        description:
+          'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update, refine, or redo a previously generated image so the existing chat resource stays current instead of creating a duplicate like "image (1).png". The file ID is returned by previous generate_image or generate_visualization calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+      },
+      prompt: {
+        type: 'string',
+        description:
+          'Detailed text description of the image to generate, or editing instructions when used with editFileId.',
+      },
+      referenceFileIds: {
+        type: 'array',
+        description:
+          'File IDs of workspace images to include as context for the generation. All images are sent alongside the prompt. Use for: editing a single image (1 file), compositing multiple images together (2+ files), style transfer, face swapping, etc. Order matters — list the primary/base image first. When revising an existing image in place, pair the primary file ID here with overwriteFileId set to that same ID.',
+        items: { type: 'string' },
+      },
+    },
+    required: ['prompt'],
+  },
+  requiredPermission: 'write',
+}
+
+export const GenerateVisualization: ToolCatalogEntry = {
+  id: 'generate_visualization',
+  name: 'generate_visualization',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description:
+          "Python code that generates a visualization using matplotlib. MUST call plt.savefig('/home/user/output.png', dpi=150, bbox_inches='tight') to produce output.",
+      },
+      fileName: {
+        type: 'string',
+        description:
+          'Output file name. Defaults to "chart.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+      },
+      inputFiles: {
+        type: 'array',
+        description:
+          'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}.',
+        items: { type: 'string' },
+      },
+      inputTables: {
+        type: 'array',
+        description:
+          "Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Read with pandas: pd.read_csv('/home/user/tables/tbl_xxx.csv')",
+        items: { type: 'string' },
+      },
+      overwriteFileId: {
+        type: 'string',
+        description:
+          'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update, refine, or redo a previously generated chart so the existing chat resource stays current instead of creating a duplicate like "chart (1).png". The file ID is returned by previous generate_visualization or generate_image calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+      },
+    },
+    required: ['code'],
+  },
+  requiredPermission: 'write',
+}
+
+export const GetBlockOutputs: ToolCatalogEntry = {
+  id: 'get_block_outputs',
+  name: 'get_block_outputs',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      blockIds: {
+        type: 'array',
+        description:
+          'Optional array of block UUIDs. If provided, returns outputs only for those blocks. If not provided, returns outputs for all blocks in the workflow.',
+        items: { type: 'string' },
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+  },
+}
+
+export const GetBlockUpstreamReferences: ToolCatalogEntry = {
+  id: 'get_block_upstream_references',
+  name: 'get_block_upstream_references',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      blockIds: {
+        type: 'array',
+        description:
+          'Required array of block UUIDs (minimum 1). Returns what each block can reference based on its position in the workflow graph.',
+        items: { type: 'string' },
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['blockIds'],
+  },
+}
+
+export const GetDeployedWorkflowState: ToolCatalogEntry = {
+  id: 'get_deployed_workflow_state',
+  name: 'get_deployed_workflow_state',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+  },
+}
+
+export const GetDeploymentVersion: ToolCatalogEntry = {
+  id: 'get_deployment_version',
+  name: 'get_deployment_version',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      version: { type: 'number', description: 'The deployment version number' },
+      workflowId: { type: 'string', description: 'The workflow ID' },
+    },
+    required: ['workflowId', 'version'],
+  },
+}
+
+export const GetExecutionSummary: ToolCatalogEntry = {
+  id: 'get_execution_summary',
+  name: 'get_execution_summary',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'number',
+        description: 'Max number of executions to return (default: 10, max: 20).',
+      },
+      status: {
+        type: 'string',
+        description: "Filter by status: 'success', 'error', or 'all' (default: 'all').",
+        enum: ['success', 'error', 'all'],
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID. If omitted, returns executions across all workflows in the workspace.',
+      },
+      workspaceId: { type: 'string', description: 'Workspace ID to scope executions to.' },
+    },
+    required: ['workspaceId'],
+  },
+}
+
+export const GetJobLogs: ToolCatalogEntry = {
+  id: 'get_job_logs',
+  name: 'get_job_logs',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      executionId: { type: 'string', description: 'Optional execution ID for a specific run.' },
+      includeDetails: {
+        type: 'boolean',
+        description: 'Include tool calls, outputs, and cost details.',
+      },
+      jobId: { type: 'string', description: 'The job (schedule) ID to get logs for.' },
+      limit: { type: 'number', description: 'Max number of entries (default: 3, max: 5)' },
+    },
+    required: ['jobId'],
+  },
+}
+
+export const GetPageContents: ToolCatalogEntry = {
+  id: 'get_page_contents',
+  name: 'get_page_contents',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      include_highlights: {
+        type: 'boolean',
+        description: 'Include key highlights (default false)',
+      },
+      include_summary: {
+        type: 'boolean',
+        description: 'Include AI-generated summary (default false)',
+      },
+      include_text: { type: 'boolean', description: 'Include full page text (default true)' },
+      urls: {
+        type: 'array',
+        description: 'URLs to get content from (max 10)',
+        items: { type: 'string' },
+      },
+    },
+    required: ['urls'],
+  },
+}
+
+export const GetPlatformActions: ToolCatalogEntry = {
+  id: 'get_platform_actions',
+  name: 'get_platform_actions',
+  route: 'sim',
+  mode: 'async',
+  parameters: { type: 'object', properties: {} },
+}
+
+export const GetWorkflowData: ToolCatalogEntry = {
+  id: 'get_workflow_data',
+  name: 'get_workflow_data',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      data_type: {
+        type: 'string',
+        description: 'The type of workflow data to retrieve',
+        enum: ['global_variables', 'custom_tools', 'mcp_tools', 'files'],
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['data_type'],
+  },
+}
+
+export const GetWorkflowLogs: ToolCatalogEntry = {
+  id: 'get_workflow_logs',
+  name: 'get_workflow_logs',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      executionId: {
+        type: 'string',
+        description:
+          'Optional execution ID to get logs for a specific execution. Use with get_execution_summary to find execution IDs first.',
+      },
+      includeDetails: { type: 'boolean', description: 'Include detailed info' },
+      limit: { type: 'number', description: 'Max number of entries (hard limit: 3)' },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+  },
+}
+
+export const Glob: ToolCatalogEntry = {
+  id: 'glob',
+  name: 'glob',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      pattern: {
+        type: 'string',
+        description:
+          'Glob pattern to match file paths. Supports * (any segment) and ** (any depth).',
+      },
+      toolTitle: {
+        type: 'string',
+        description:
+          'Optional target-only UI phrase for the search row. The UI verb is supplied for you, so pass text like "workflow configs" or "knowledge bases", not a full sentence like "Finding workflow configs".',
+      },
+    },
+    required: ['pattern', 'toolTitle'],
+  },
+}
+
+export const Grep: ToolCatalogEntry = {
+  id: 'grep',
+  name: 'grep',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      context: {
+        type: 'number',
+        description:
+          "Number of lines to show before and after each match. Only applies to output_mode 'content'.",
+      },
+      ignoreCase: { type: 'boolean', description: 'Case insensitive search (default false).' },
+      lineNumbers: {
+        type: 'boolean',
+        description:
+          "Include line numbers in output (default true). Only applies to output_mode 'content'.",
+      },
+      maxResults: {
+        type: 'number',
+        description: 'Maximum number of matches to return (default 50).',
+      },
+      output_mode: {
+        type: 'string',
+        description:
+          "Output mode: 'content' shows matching lines (default), 'files_with_matches' shows only file paths, 'count' shows match counts per file.",
+        enum: ['content', 'files_with_matches', 'count'],
+      },
+      path: {
+        type: 'string',
+        description:
+          "Optional path prefix to scope the search (e.g. 'workflows/', 'environment/', 'internal/', 'components/blocks/').",
+      },
+      pattern: { type: 'string', description: 'Regex pattern to search for in file contents.' },
+      toolTitle: {
+        type: 'string',
+        description:
+          'Optional target-only UI phrase for the search row. The UI verb is supplied for you, so pass text like "Slack integrations" or "deployed workflows", not a full sentence like "Searching for Slack integrations".',
+      },
+    },
+    required: ['pattern', 'toolTitle'],
+  },
+}
+
+export const Job: ToolCatalogEntry = {
+  id: 'job',
+  name: 'job',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: { request: { description: 'What job action is needed.', type: 'string' } },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'job',
+  internal: true,
+}
+
+export const Knowledge: ToolCatalogEntry = {
+  id: 'knowledge',
+  name: 'knowledge',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: { description: 'What knowledge base action is needed.', type: 'string' },
+    },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'knowledge',
+  internal: true,
+}
+
+export const KnowledgeBase: ToolCatalogEntry = {
+  id: 'knowledge_base',
+  name: 'knowledge_base',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          apiKey: {
+            type: 'string',
+            description:
+              'API key for API-key-based connectors (required when connector auth mode is apiKey)',
+          },
+          chunkingConfig: {
+            type: 'object',
+            description: "Chunking configuration (optional for 'create')",
+            properties: {
+              maxSize: {
+                type: 'number',
+                description: 'Maximum chunk size (100-4000, default: 1024)',
+                default: 1024,
+              },
+              minSize: {
+                type: 'number',
+                description: 'Minimum chunk size (1-2000, default: 1)',
+                default: 1,
+              },
+              overlap: {
+                type: 'number',
+                description: 'Overlap between chunks (0-500, default: 200)',
+                default: 200,
+              },
+            },
+          },
+          connectorId: {
+            type: 'string',
+            description:
+              'Connector ID (required for update_connector, delete_connector, sync_connector)',
+          },
+          connectorStatus: {
+            type: 'string',
+            description: 'Connector status (optional for update_connector)',
+            enum: ['active', 'paused'],
+          },
+          connectorType: {
+            type: 'string',
+            description:
+              "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
+          },
+          credentialId: {
+            type: 'string',
+            description:
+              'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
+          },
+          description: {
+            type: 'string',
+            description: "Description of the knowledge base (optional for 'create')",
+          },
+          disabledTagIds: {
+            type: 'array',
+            description:
+              'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
+          },
+          documentId: { type: 'string', description: 'Document ID (required for update_document)' },
+          documentIds: {
+            type: 'array',
+            description: 'Document IDs (for batch delete_document)',
+            items: { type: 'string' },
+          },
+          enabled: {
+            type: 'boolean',
+            description: 'Enable/disable a document (optional for update_document)',
+          },
+          fileIds: {
+            type: 'array',
+            description:
+              'Canonical workspace file IDs to add as documents (for add_file). Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+            items: { type: 'string' },
+          },
+          filename: {
+            type: 'string',
+            description: 'New filename for a document (optional for update_document)',
+          },
+          knowledgeBaseId: {
+            type: 'string',
+            description:
+              'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
+          },
+          knowledgeBaseIds: {
+            type: 'array',
+            description: 'Knowledge base IDs (for batch delete)',
+            items: { type: 'string' },
+          },
+          name: {
+            type: 'string',
+            description: "Name of the knowledge base (required for 'create')",
+          },
+          query: { type: 'string', description: "Search query text (required for 'query')" },
+          sourceConfig: {
+            type: 'object',
+            description:
+              'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
+          },
+          syncIntervalMinutes: {
+            type: 'number',
+            description:
+              'Sync interval in minutes: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
+            default: 1440,
+          },
+          tagDefinitionId: {
+            type: 'string',
+            description: 'Tag definition ID (required for update_tag, delete_tag)',
+          },
+          tagDisplayName: {
+            type: 'string',
+            description:
+              'Display name for the tag (required for create_tag, optional for update_tag)',
+          },
+          tagFieldType: {
+            type: 'string',
+            description:
+              'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
+            enum: ['text', 'number', 'date', 'boolean'],
+          },
+          topK: {
+            type: 'number',
+            description: 'Number of results to return (1-50, default: 5)',
+            default: 5,
+          },
+          workspaceId: {
+            type: 'string',
+            description: "Workspace ID (required for 'create', optional filter for 'list')",
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform',
+        enum: [
+          'create',
+          'get',
+          'query',
+          'add_file',
+          'update',
+          'delete',
+          'delete_document',
+          'update_document',
+          'list_tags',
+          'create_tag',
+          'update_tag',
+          'delete_tag',
+          'get_tag_usage',
+          'add_connector',
+          'update_connector',
+          'delete_connector',
+          'sync_connector',
+        ],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiresConfirmation: true,
+}
+
+export const ListFolders: ToolCatalogEntry = {
+  id: 'list_folders',
+  name: 'list_folders',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workspaceId: { type: 'string', description: 'Optional workspace ID to list folders for.' },
+    },
+  },
+}
+
+export const ListUserWorkspaces: ToolCatalogEntry = {
+  id: 'list_user_workspaces',
+  name: 'list_user_workspaces',
+  route: 'sim',
+  mode: 'async',
+  parameters: { type: 'object', properties: {} },
+}
+
+export const ListWorkspaceMcpServers: ToolCatalogEntry = {
+  id: 'list_workspace_mcp_servers',
+  name: 'list_workspace_mcp_servers',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workspaceId: { type: 'string', description: 'Workspace ID (defaults to current workspace)' },
+    },
+  },
+}
+
+export const ManageCredential: ToolCatalogEntry = {
+  id: 'manage_credential',
+  name: 'manage_credential',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      credentialId: { type: 'string', description: 'The credential ID (required for rename)' },
+      credentialIds: {
+        type: 'array',
+        description: 'Array of credential IDs (for batch delete)',
+        items: { type: 'string' },
+      },
+      displayName: { type: 'string', description: 'New display name (required for rename)' },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform',
+        enum: ['rename', 'delete'],
+      },
+    },
+    required: ['operation'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const ManageCustomTool: ToolCatalogEntry = {
+  id: 'manage_custom_tool',
+  name: 'manage_custom_tool',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description:
+          'The JavaScript code that executes when the tool is called (required for add). Parameters from schema are available as variables. Function body only - no signature or wrapping braces.',
+      },
+      operation: {
+        type: 'string',
+        description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+        enum: ['add', 'edit', 'delete', 'list'],
+      },
+      schema: {
+        type: 'object',
+        description: 'The tool schema in OpenAI function calling format (required for add).',
+        properties: {
+          function: {
+            type: 'object',
+            description: 'The function definition',
+            properties: {
+              description: { type: 'string', description: 'What the function does' },
+              name: { type: 'string', description: 'The function name (camelCase)' },
+              parameters: {
+                type: 'object',
+                description: 'The function parameters schema',
+                properties: {
+                  properties: {
+                    type: 'object',
+                    description: 'Parameter definitions as key-value pairs',
+                  },
+                  required: {
+                    type: 'array',
+                    description: 'Array of required parameter names',
+                    items: { type: 'string' },
+                  },
+                  type: { type: 'string', description: "Must be 'object'" },
+                },
+                required: ['type', 'properties'],
+              },
+            },
+            required: ['name', 'parameters'],
+          },
+          type: { type: 'string', description: "Must be 'function'" },
+        },
+        required: ['type', 'function'],
+      },
+      toolId: {
+        type: 'string',
+        description:
+          "The ID of the custom tool (required for edit). Must be the exact toolId from the get_workflow_data custom tool response - do not guess or construct it. DO NOT PROVIDE THE TOOL ID IF THE OPERATION IS 'ADD'.",
+      },
+      toolIds: {
+        type: 'array',
+        description: 'Array of custom tool IDs (for batch delete)',
+        items: { type: 'string' },
+      },
+    },
+    required: ['operation'],
+  },
+  requiresConfirmation: true,
+}
+
+export const ManageJob: ToolCatalogEntry = {
+  id: 'manage_job',
+  name: 'manage_job',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description:
+          'Operation-specific arguments. For create: {title, prompt, cron?, time?, timezone?, lifecycle?, successCondition?, maxRuns?}. For get/delete: {jobId}. For update: {jobId, title?, prompt?, cron?, timezone?, status?, lifecycle?, successCondition?, maxRuns?}. For list: no args needed.',
+        properties: {
+          cron: { type: 'string', description: 'Cron expression for recurring jobs' },
+          jobId: { type: 'string', description: 'Job ID (required for get, update)' },
+          jobIds: {
+            type: 'array',
+            description: 'Array of job IDs (for batch delete)',
+            items: { type: 'string' },
+          },
+          lifecycle: {
+            type: 'string',
+            description:
+              "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called.",
+          },
+          maxRuns: {
+            type: 'integer',
+            description: 'Max executions before auto-completing. Safety limit.',
+          },
+          prompt: { type: 'string', description: 'The prompt to execute when the job fires' },
+          status: { type: 'string', description: 'Job status: active, paused' },
+          successCondition: {
+            type: 'string',
+            description:
+              'What must happen for the job to be considered complete (until_complete lifecycle).',
+          },
+          time: {
+            type: 'string',
+            description: 'ISO 8601 datetime for one-time jobs or cron start time',
+          },
+          timezone: {
+            type: 'string',
+            description: 'IANA timezone (e.g. America/New_York). Defaults to UTC.',
+          },
+          title: {
+            type: 'string',
+            description: "Short descriptive title for the job (e.g. 'Email Poller')",
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform: create, list, get, update, delete',
+        enum: ['create', 'list', 'get', 'update', 'delete'],
+      },
+    },
+    required: ['operation'],
+  },
+}
+
+export const ManageMcpTool: ToolCatalogEntry = {
+  id: 'manage_mcp_tool',
+  name: 'manage_mcp_tool',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      config: {
+        type: 'object',
+        description: 'Required for add and edit. The MCP server configuration.',
+        properties: {
+          enabled: {
+            type: 'boolean',
+            description: 'Whether the server is enabled (default: true)',
+          },
+          headers: {
+            type: 'object',
+            description: 'Optional HTTP headers to send with requests (key-value pairs)',
+          },
+          name: { type: 'string', description: 'Display name for the MCP server' },
+          timeout: {
+            type: 'number',
+            description: 'Request timeout in milliseconds (default: 30000)',
+          },
+          transport: {
+            type: 'string',
+            description: "Transport protocol: 'streamable-http' or 'sse'",
+            enum: ['streamable-http', 'sse'],
+            default: 'streamable-http',
+          },
+          url: { type: 'string', description: 'The MCP server endpoint URL (required for add)' },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+        enum: ['add', 'edit', 'delete', 'list'],
+      },
+      serverId: {
+        type: 'string',
+        description:
+          "Required for edit and delete. The database ID of the MCP server. DO NOT PROVIDE if operation is 'add' or 'list'.",
+      },
+    },
+    required: ['operation'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const ManageSkill: ToolCatalogEntry = {
+  id: 'manage_skill',
+  name: 'manage_skill',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'Markdown instructions for the skill. Required for add, optional for edit.',
+      },
+      description: {
+        type: 'string',
+        description: 'Short description of the skill. Required for add, optional for edit.',
+      },
+      name: {
+        type: 'string',
+        description:
+          "Skill name in kebab-case (e.g. 'my-skill'). Required for add, optional for edit.",
+      },
+      operation: {
+        type: 'string',
+        description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+        enum: ['add', 'edit', 'delete', 'list'],
+      },
+      skillId: {
+        type: 'string',
+        description:
+          "The ID of the skill (required for edit/delete). Must be the exact ID from the VFS or list. DO NOT PROVIDE if operation is 'add' or 'list'.",
+      },
+    },
+    required: ['operation'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const MaterializeFile: ToolCatalogEntry = {
+  id: 'materialize_file',
+  name: 'materialize_file',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      fileNames: {
+        type: 'array',
+        description:
+          'The names of the uploaded files to materialize (e.g. ["report.pdf", "data.csv"])',
+        items: { type: 'string' },
+      },
+      knowledgeBaseId: {
+        type: 'string',
+        description:
+          'ID of an existing knowledge base to add the file to (only used with operation "knowledge_base"). If omitted, a new KB is created.',
+      },
+      operation: {
+        type: 'string',
+        description:
+          'What to do with the file. "save" promotes it to files/. "import" imports a workflow JSON. "table" converts CSV/TSV/JSON to a table. "knowledge_base" saves and adds to a KB. Defaults to "save".',
+        enum: ['save', 'import', 'table', 'knowledge_base'],
+        default: 'save',
+      },
+      tableName: {
+        type: 'string',
+        description:
+          'Custom name for the table (only used with operation "table"). Defaults to the file name without extension.',
+      },
+    },
+    required: ['fileNames'],
+  },
+  requiredPermission: 'write',
+}
+
+export const MoveFolder: ToolCatalogEntry = {
+  id: 'move_folder',
+  name: 'move_folder',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      folderId: { type: 'string', description: 'The folder ID to move.' },
+      parentId: {
+        type: 'string',
+        description:
+          'Target parent folder ID. Omit or pass empty string to move to workspace root.',
+      },
+    },
+    required: ['folderId'],
+  },
+  requiredPermission: 'write',
+}
+
+export const MoveWorkflow: ToolCatalogEntry = {
+  id: 'move_workflow',
+  name: 'move_workflow',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      folderId: {
+        type: 'string',
+        description: 'Target folder ID. Omit or pass empty string to move to workspace root.',
+      },
+      workflowIds: {
+        type: 'array',
+        description: 'The workflow IDs to move.',
+        items: { type: 'string' },
+      },
+    },
+    required: ['workflowIds'],
+  },
+  requiredPermission: 'write',
+}
+
+export const OauthGetAuthLink: ToolCatalogEntry = {
+  id: 'oauth_get_auth_link',
+  name: 'oauth_get_auth_link',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      providerName: {
+        type: 'string',
+        description:
+          "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar', 'GitHub')",
+      },
+    },
+    required: ['providerName'],
+  },
+}
+
+export const OauthRequestAccess: ToolCatalogEntry = {
+  id: 'oauth_request_access',
+  name: 'oauth_request_access',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      providerName: {
+        type: 'string',
+        description:
+          "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar')",
+      },
+    },
+    required: ['providerName'],
+  },
+  requiresConfirmation: true,
+}
+
+export const OpenResource: ToolCatalogEntry = {
+  id: 'open_resource',
+  name: 'open_resource',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      resources: {
+        type: 'array',
+        description: 'Array of resources to open. Each item must have type and id.',
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'The resource ID.' },
+            type: {
+              type: 'string',
+              description: 'The resource type.',
+              enum: ['workflow', 'table', 'knowledgebase', 'file', 'log'],
+            },
+          },
+          required: ['type', 'id'],
+        },
+      },
+    },
+    required: ['resources'],
+  },
+}
+
+export const Read: ToolCatalogEntry = {
+  id: 'read',
+  name: 'read',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      limit: { type: 'number', description: 'Maximum number of lines to read.' },
+      offset: { type: 'number', description: 'Line offset to start reading from (0-indexed).' },
+      outputTable: {
+        type: 'string',
+        description:
+          'Table ID to import the file contents into (CSV/JSON). All existing rows are replaced. Example: "tbl_abc123"',
+      },
+      path: {
+        type: 'string',
+        description: "Path to the file to read (e.g. 'workflows/My Workflow/state.json').",
+      },
+    },
+    required: ['path'],
+  },
+}
+
+export const Redeploy: ToolCatalogEntry = {
+  id: 'redeploy',
+  name: 'redeploy',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      workflowId: {
+        type: 'string',
+        description: 'Workflow ID to redeploy (required in workspace context)',
+      },
+    },
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      apiEndpoint: { type: 'string', description: 'Canonical workflow execution endpoint.' },
+      baseUrl: { type: 'string', description: 'Base URL used to construct deployment URLs.' },
+      deployedAt: {
+        type: 'string',
+        description: 'Deployment timestamp when the workflow is deployed.',
+      },
+      deploymentConfig: {
+        type: 'object',
+        description:
+          'Structured deployment configuration keyed by surface name. For API deploys this includes endpoint, auth, and sync/stream/async mode details.',
+      },
+      deploymentStatus: {
+        type: 'object',
+        description: 'Structured per-surface deployment status keyed by surface name, such as api.',
+      },
+      deploymentType: {
+        type: 'string',
+        description:
+          'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+      },
+      examples: {
+        type: 'object',
+        description:
+          'Invocation examples keyed by surface name. For API deploys this includes curl examples for sync, stream, async, and polling.',
+      },
+      isDeployed: {
+        type: 'boolean',
+        description: 'Whether the workflow API is currently deployed after this tool call.',
+      },
+      version: {
+        type: 'number',
+        description: 'Deployment version for the current API deployment.',
+      },
+      workflowId: { type: 'string', description: 'Workflow ID that was deployed or undeployed.' },
+    },
+    required: [
+      'workflowId',
+      'isDeployed',
+      'deploymentType',
+      'deploymentStatus',
+      'deploymentConfig',
+      'examples',
+    ],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const RenameFile: ToolCatalogEntry = {
+  id: 'rename_file',
+  name: 'rename_file',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      fileId: { type: 'string', description: 'Canonical workspace file ID of the file to rename.' },
+      newName: {
+        type: 'string',
+        description:
+          'New filename including extension, e.g. "draft_v2.md". Must not contain slashes.',
+      },
+    },
+    required: ['fileId', 'newName'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Contains id and the new name.' },
+      message: { type: 'string', description: 'Human-readable outcome.' },
+      success: { type: 'boolean', description: 'Whether the rename succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiredPermission: 'write',
+}
+
+export const RenameWorkflow: ToolCatalogEntry = {
+  id: 'rename_workflow',
+  name: 'rename_workflow',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'The new name for the workflow.' },
+      workflowId: { type: 'string', description: 'The workflow ID to rename.' },
+    },
+    required: ['workflowId', 'name'],
+  },
+  requiredPermission: 'write',
+}
+
+export const Research: ToolCatalogEntry = {
+  id: 'research',
+  name: 'research',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: { topic: { description: 'The topic to research.', type: 'string' } },
+    required: ['topic'],
+    type: 'object',
+  },
+  subagentId: 'research',
+  internal: true,
+}
+
+export const Respond: ToolCatalogEntry = {
+  id: 'respond',
+  name: 'respond',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    additionalProperties: true,
+    properties: {
+      output: {
+        description:
+          'The result — facts, status, VFS paths to persisted data, whatever the caller needs to act on.',
+        type: 'string',
+      },
+      success: { description: 'Whether the task completed successfully', type: 'boolean' },
+      type: { description: 'Optional logical result type override', type: 'string' },
+    },
+    required: ['output', 'success'],
+    type: 'object',
+  },
+  internal: true,
+  hidden: true,
+}
+
+export const RestoreResource: ToolCatalogEntry = {
+  id: 'restore_resource',
+  name: 'restore_resource',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      id: { type: 'string', description: 'The canonical resource ID to restore.' },
+      type: {
+        type: 'string',
+        description: 'The resource type to restore.',
+        enum: ['workflow', 'table', 'file', 'knowledgebase', 'folder'],
+      },
+    },
+    required: ['type', 'id'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const RevertToVersion: ToolCatalogEntry = {
+  id: 'revert_to_version',
+  name: 'revert_to_version',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      version: { type: 'number', description: 'The deployment version number to revert to' },
+      workflowId: { type: 'string', description: 'The workflow ID' },
+    },
+    required: ['workflowId', 'version'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const RunBlock: ToolCatalogEntry = {
+  id: 'run_block',
+  name: 'run_block',
+  route: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      blockId: { type: 'string', description: 'The block ID to run in isolation.' },
+      executionId: {
+        type: 'string',
+        description:
+          'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+      },
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['blockId'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const RunFromBlock: ToolCatalogEntry = {
+  id: 'run_from_block',
+  name: 'run_from_block',
+  route: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      executionId: {
+        type: 'string',
+        description:
+          'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+      },
+      startBlockId: { type: 'string', description: 'The block ID to start execution from.' },
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['startBlockId'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const RunWorkflow: ToolCatalogEntry = {
+  id: 'run_workflow',
+  name: 'run_workflow',
+  route: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      triggerBlockId: {
+        type: 'string',
+        description:
+          'Optional trigger block ID when the workflow has multiple entrypoints and you need to target a specific one.',
+      },
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['workflow_input'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const RunWorkflowUntilBlock: ToolCatalogEntry = {
+  id: 'run_workflow_until_block',
+  name: 'run_workflow_until_block',
+  route: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      stopAfterBlockId: {
+        type: 'string',
+        description: 'The block ID to stop after. Execution halts once this block completes.',
+      },
+      triggerBlockId: {
+        type: 'string',
+        description:
+          'Optional trigger block ID when the workflow has multiple entrypoints and you need to target a specific one.',
+      },
+      useDeployedState: {
+        type: 'boolean',
+        description:
+          'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+      },
+      workflow_input: {
+        type: 'object',
+        description: 'JSON object with key-value mappings where each key is an input field name',
+      },
+    },
+    required: ['stopAfterBlockId'],
+  },
+  clientExecutable: true,
+  requiresConfirmation: true,
+}
+
+export const ScrapePage: ToolCatalogEntry = {
+  id: 'scrape_page',
+  name: 'scrape_page',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      include_links: {
+        type: 'boolean',
+        description: 'Extract all links from the page (default false)',
+      },
+      url: { type: 'string', description: 'The URL to scrape (must include https://)' },
+      wait_for: {
+        type: 'string',
+        description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+      },
+    },
+    required: ['url'],
+  },
+}
+
+export const SearchDocumentation: ToolCatalogEntry = {
+  id: 'search_documentation',
+  name: 'search_documentation',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'The search query' },
+      topK: { type: 'number', description: 'Number of results (max 10)' },
+    },
+    required: ['query'],
+  },
+}
+
+export const SearchLibraryDocs: ToolCatalogEntry = {
+  id: 'search_library_docs',
+  name: 'search_library_docs',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      library_name: {
+        type: 'string',
+        description: "Name of the library to search for (e.g., 'nextjs', 'stripe', 'langchain')",
+      },
+      query: {
+        type: 'string',
+        description: 'The question or topic to find documentation for - be specific',
+      },
+      version: { type: 'string', description: "Specific version (optional, e.g., '14', 'v2')" },
+    },
+    required: ['library_name', 'query'],
+  },
+}
+
+export const SearchOnline: ToolCatalogEntry = {
+  id: 'search_online',
+  name: 'search_online',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        description: 'Filter by category',
+        enum: [
+          'news',
+          'tweet',
+          'github',
+          'paper',
+          'company',
+          'research paper',
+          'linkedin profile',
+          'pdf',
+          'personal site',
+        ],
+      },
+      include_text: { type: 'boolean', description: 'Include page text content (default true)' },
+      num_results: { type: 'number', description: 'Number of results (default 10, max 25)' },
+      query: { type: 'string', description: 'Natural language search query' },
+      toolTitle: {
+        type: 'string',
+        description:
+          'Optional target-only UI phrase for the search row. The UI verb is supplied for you, so pass text like "pricing changes" or "Slack webhook docs", not a full sentence like "Searching online for pricing changes".',
+      },
+    },
+    required: ['query', 'toolTitle'],
+  },
+}
+
+export const SearchPatterns: ToolCatalogEntry = {
+  id: 'search_patterns',
+  name: 'search_patterns',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      limit: {
+        type: 'integer',
+        description: 'Maximum number of unique pattern examples to return (defaults to 3).',
+      },
+      queries: {
+        type: 'array',
+        description:
+          'Up to 3 descriptive strings explaining the workflow pattern(s) you need. Focus on intent and desired outcomes.',
+        items: {
+          type: 'string',
+          description: 'Example: "how to automate wealthbox meeting notes into follow-up tasks"',
+        },
+      },
+    },
+    required: ['queries'],
+  },
+}
+
+export const SetBlockEnabled: ToolCatalogEntry = {
+  id: 'set_block_enabled',
+  name: 'set_block_enabled',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      blockId: {
+        type: 'string',
+        description: 'The block ID whose enabled state should be changed.',
+      },
+      enabled: {
+        type: 'boolean',
+        description: 'Set to true to enable the block, or false to disable it.',
+      },
+      workflowId: {
+        type: 'string',
+        description:
+          'Optional workflow ID to edit. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['blockId', 'enabled'],
+  },
+  requiredPermission: 'write',
+}
+
+export const SetEnvironmentVariables: ToolCatalogEntry = {
+  id: 'set_environment_variables',
+  name: 'set_environment_variables',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      variables: {
+        type: 'array',
+        description: 'List of env vars to set',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Variable name' },
+            value: { type: 'string', description: 'Variable value' },
+          },
+          required: ['name', 'value'],
+        },
+      },
+    },
+    required: ['variables'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const SetGlobalWorkflowVariables: ToolCatalogEntry = {
+  id: 'set_global_workflow_variables',
+  name: 'set_global_workflow_variables',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      operations: {
+        type: 'array',
+        description: 'List of operations to apply',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            operation: { type: 'string', enum: ['add', 'delete', 'edit'] },
+            type: { type: 'string', enum: ['plain', 'number', 'boolean', 'array', 'object'] },
+            value: { type: 'string' },
+          },
+          required: ['operation', 'name', 'type', 'value'],
+        },
+      },
+      workflowId: {
+        type: 'string',
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+      },
+    },
+    required: ['operations'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'write',
+}
+
+export const Superagent: ToolCatalogEntry = {
+  id: 'superagent',
+  name: 'superagent',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      task: {
+        description:
+          "A single sentence — the agent has full conversation context. Do NOT pre-read credentials or look up configs. Example: 'send the email we discussed' or 'check my calendar for tomorrow'.",
+        type: 'string',
+      },
+    },
+    required: ['task'],
+    type: 'object',
+  },
+  subagentId: 'superagent',
+  internal: true,
+}
+
+export const Table: ToolCatalogEntry = {
+  id: 'table',
+  name: 'table',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: { request: { description: 'What table action is needed.', type: 'string' } },
+    required: ['request'],
+    type: 'object',
+  },
+  subagentId: 'table',
+  internal: true,
+}
+
+export const ToolSearchToolRegex: ToolCatalogEntry = {
+  id: 'tool_search_tool_regex',
+  name: 'tool_search_tool_regex',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    properties: {
+      case_insensitive: {
+        description: 'Whether the regex should be case-insensitive (default true).',
+        type: 'boolean',
+      },
+      max_results: {
+        description: 'Maximum number of tools to return (optional).',
+        type: 'integer',
+      },
+      pattern: {
+        description: 'Regular expression to match tool names or descriptions.',
+        type: 'string',
+      },
+    },
+    required: ['pattern'],
+    type: 'object',
+  },
+}
+
+export const UpdateJobHistory: ToolCatalogEntry = {
+  id: 'update_job_history',
+  name: 'update_job_history',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      jobId: { type: 'string', description: 'The job ID.' },
+      summary: {
+        type: 'string',
+        description:
+          "A concise summary of what was done this run (e.g., 'Sent follow-up emails to 3 leads: Alice, Bob, Carol').",
+      },
+    },
+    required: ['jobId', 'summary'],
+  },
+}
+
+export const UpdateWorkspaceMcpServer: ToolCatalogEntry = {
+  id: 'update_workspace_mcp_server',
+  name: 'update_workspace_mcp_server',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      description: { type: 'string', description: 'New description for the server' },
+      isPublic: { type: 'boolean', description: 'Whether the server is publicly accessible' },
+      name: { type: 'string', description: 'New name for the server' },
+      serverId: { type: 'string', description: 'Required: the MCP server ID to update' },
+    },
+    required: ['serverId'],
+  },
+  requiresConfirmation: true,
+  requiredPermission: 'admin',
+}
+
+export const UserMemory: ToolCatalogEntry = {
+  id: 'user_memory',
+  name: 'user_memory',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      confidence: {
+        type: 'number',
+        description: 'Confidence level 0-1 (default 1.0 for explicit, 0.8 for inferred)',
+      },
+      correct_value: {
+        type: 'string',
+        description: "The correct value to replace the wrong one (for 'correct' operation)",
+      },
+      key: {
+        type: 'string',
+        description: "Unique key for the memory (e.g., 'preferred_model', 'slack_credential')",
+      },
+      limit: { type: 'number', description: 'Number of results for search (default 10)' },
+      memory_type: {
+        type: 'string',
+        description: "Type of memory: 'preference', 'entity', 'history', or 'correction'",
+        enum: ['preference', 'entity', 'history', 'correction'],
+      },
+      operation: {
+        type: 'string',
+        description: "Operation: 'add', 'search', 'delete', 'correct', or 'list'",
+        enum: ['add', 'search', 'delete', 'correct', 'list'],
+      },
+      query: { type: 'string', description: 'Search query to find relevant memories' },
+      source: {
+        type: 'string',
+        description: "Source: 'explicit' (user told you) or 'inferred' (you observed)",
+        enum: ['explicit', 'inferred'],
+      },
+      value: { type: 'string', description: 'Value to remember' },
+    },
+    required: ['operation'],
+  },
+}
+
+export const UserTable: ToolCatalogEntry = {
+  id: 'user_table',
+  name: 'user_table',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          column: {
+            type: 'object',
+            description: 'Column definition for add_column: { name, type, unique?, position? }',
+          },
+          columnName: {
+            type: 'string',
+            description:
+              'Column name (required for rename_column, update_column; use columnNames array for batch delete_column)',
+          },
+          columnNames: {
+            type: 'array',
+            description:
+              'Array of column names to delete at once (for delete_column). Preferred over columnName when deleting multiple columns.',
+          },
+          data: {
+            type: 'object',
+            description: 'Row data as key-value pairs (required for insert_row, update_row)',
+          },
+          description: { type: 'string', description: "Table description (optional for 'create')" },
+          fileId: {
+            type: 'string',
+            description:
+              'Canonical workspace file ID for create_from_file/import_file. Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+          },
+          filePath: {
+            type: 'string',
+            description:
+              'Legacy workspace file reference for create_from_file/import_file. Prefer fileId.',
+          },
+          filter: {
+            type: 'object',
+            description:
+              'MongoDB-style filter for query_rows, update_rows_by_filter, delete_rows_by_filter',
+          },
+          limit: {
+            type: 'number',
+            description: 'Maximum rows to return or affect (optional, default 100)',
+          },
+          name: { type: 'string', description: "Table name (required for 'create')" },
+          newName: { type: 'string', description: 'New column name (required for rename_column)' },
+          newType: {
+            type: 'string',
+            description:
+              'New column type (optional for update_column). Types: string, number, boolean, date, json',
+          },
+          offset: {
+            type: 'number',
+            description: 'Number of rows to skip (optional for query_rows, default 0)',
+          },
+          outputFormat: {
+            type: 'string',
+            description:
+              'Explicit format override for outputPath. Usually unnecessary — the file extension determines the format automatically. Only use this to force a different format than what the extension implies.',
+            enum: ['json', 'csv', 'txt', 'md', 'html'],
+          },
+          outputPath: {
+            type: 'string',
+            description:
+              'Pipe query_rows results directly to a NEW workspace file. The format is auto-inferred from the file extension: .csv → CSV, .json → JSON, .md → Markdown, etc. Use .csv for tabular exports. Use a flat path like "files/export.csv" — nested paths are not supported.',
+          },
+          rowId: {
+            type: 'string',
+            description: 'Row ID (required for get_row, update_row, delete_row)',
+          },
+          rowIds: {
+            type: 'array',
+            description: 'Array of row IDs to delete (for batch_delete_rows)',
+          },
+          rows: {
+            type: 'array',
+            description: 'Array of row data objects (required for batch_insert_rows)',
+          },
+          schema: {
+            type: 'object',
+            description:
+              "Table schema with columns array (required for 'create'). Each column: { name, type, unique? }",
+          },
+          sort: {
+            type: 'object',
+            description:
+              "Sort specification as { field: 'asc' | 'desc' } (optional for query_rows)",
+          },
+          tableId: {
+            type: 'string',
+            description:
+              "Table ID (required for most operations except 'create' and batch 'delete')",
+          },
+          tableIds: {
+            type: 'array',
+            description: 'Array of table IDs (for batch delete)',
+            items: { type: 'string' },
+          },
+          unique: {
+            type: 'boolean',
+            description: 'Set column unique constraint (optional for update_column)',
+          },
+          updates: {
+            type: 'array',
+            description:
+              'Array of per-row updates: [{ rowId, data: { col: val } }] (for batch_update_rows)',
+          },
+          values: {
+            type: 'object',
+            description:
+              'Map of rowId to value for single-column batch update: { "rowId1": val1, "rowId2": val2 } (for batch_update_rows with columnName)',
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform',
+        enum: [
+          'create',
+          'create_from_file',
+          'import_file',
+          'get',
+          'get_schema',
+          'delete',
+          'insert_row',
+          'batch_insert_rows',
+          'get_row',
+          'query_rows',
+          'update_row',
+          'delete_row',
+          'update_rows_by_filter',
+          'delete_rows_by_filter',
+          'batch_update_rows',
+          'batch_delete_rows',
+          'add_column',
+          'rename_column',
+          'delete_column',
+          'update_column',
+        ],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiresConfirmation: true,
+}
+
+export const Workflow: ToolCatalogEntry = {
+  id: 'workflow',
+  name: 'workflow',
+  route: 'subagent',
+  mode: 'async',
+  parameters: { type: 'object' },
+  subagentId: 'workflow',
+  internal: true,
+}
+
+export const WorkspaceFile: ToolCatalogEntry = {
+  id: 'workspace_file',
+  name: 'workspace_file',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      operation: {
+        type: 'string',
+        description: 'The file operation to perform.',
+        enum: ['append', 'update', 'patch'],
+      },
+      target: {
+        type: 'object',
+        description: 'Explicit file target. Use kind=file_id + fileId for existing files.',
+        properties: {
+          fileId: {
+            type: 'string',
+            description: 'Canonical existing workspace file ID. Required when target.kind=file_id.',
+          },
+          fileName: {
+            type: 'string',
+            description:
+              'Plain workspace filename including extension, e.g. "main.py" or "report.docx". Required when target.kind=new_file.',
+          },
+          kind: {
+            type: 'string',
+            description: 'How the file target is identified.',
+            enum: ['new_file', 'file_id'],
+          },
+        },
+        required: ['kind'],
+      },
+      title: {
+        type: 'string',
+        description:
+          'Required short UI label for this content unit, e.g. "Chapter 1", "Slide 3", or "Fix footer spacing".',
+      },
+      contentType: {
+        type: 'string',
+        description:
+          'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
+        enum: [
+          'text/markdown',
+          'text/html',
+          'text/plain',
+          'application/json',
+          'text/csv',
+          'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+          'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+          'application/pdf',
+        ],
+      },
+      edit: {
+        type: 'object',
+        description:
+          'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. The actual replacement/insert content is provided via the paired edit_content tool call.',
+        properties: {
+          after_anchor: {
+            type: 'string',
+            description:
+              'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
+          },
+          anchor: {
+            type: 'string',
+            description:
+              'Anchor line after which new content is inserted. Required for mode=insert_after.',
+          },
+          before_anchor: {
+            type: 'string',
+            description:
+              'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
+          },
+          end_anchor: {
+            type: 'string',
+            description: 'First line to keep after deletion. Required for mode=delete_between.',
+          },
+          mode: {
+            type: 'string',
+            description: 'Anchored edit mode when strategy=anchored.',
+            enum: ['replace_between', 'insert_after', 'delete_between'],
+          },
+          occurrence: {
+            type: 'number',
+            description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
+          },
+          replaceAll: {
+            type: 'boolean',
+            description:
+              'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
+          },
+          search: {
+            type: 'string',
+            description:
+              'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
+          },
+          start_anchor: {
+            type: 'string',
+            description: 'First line to delete. Required for mode=delete_between.',
+          },
+          strategy: {
+            type: 'string',
+            description: 'Patch strategy.',
+            enum: ['search_replace', 'anchored'],
+          },
+        },
+      },
+      newName: {
+        type: 'string',
+        description: 'New file name for rename. Must be a plain workspace filename like "main.py".',
+      },
+    },
+    required: ['operation', 'target', 'title'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: {
+        type: 'object',
+        description:
+          'Optional operation metadata such as file id, file name, size, and content type.',
+      },
+      message: { type: 'string', description: 'Human-readable summary of the outcome.' },
+      success: { type: 'boolean', description: 'Whether the file operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiredPermission: 'write',
+}
+
+export const KnowledgeBaseOperation = {
+  create: 'create',
+  get: 'get',
+  query: 'query',
+  addFile: 'add_file',
+  update: 'update',
+  delete: 'delete',
+  deleteDocument: 'delete_document',
+  updateDocument: 'update_document',
+  listTags: 'list_tags',
+  createTag: 'create_tag',
+  updateTag: 'update_tag',
+  deleteTag: 'delete_tag',
+  getTagUsage: 'get_tag_usage',
+  addConnector: 'add_connector',
+  updateConnector: 'update_connector',
+  deleteConnector: 'delete_connector',
+  syncConnector: 'sync_connector',
+} as const
+
+export type KnowledgeBaseOperation =
+  (typeof KnowledgeBaseOperation)[keyof typeof KnowledgeBaseOperation]
+
+export const KnowledgeBaseOperationValues = [
+  KnowledgeBaseOperation.create,
+  KnowledgeBaseOperation.get,
+  KnowledgeBaseOperation.query,
+  KnowledgeBaseOperation.addFile,
+  KnowledgeBaseOperation.update,
+  KnowledgeBaseOperation.delete,
+  KnowledgeBaseOperation.deleteDocument,
+  KnowledgeBaseOperation.updateDocument,
+  KnowledgeBaseOperation.listTags,
+  KnowledgeBaseOperation.createTag,
+  KnowledgeBaseOperation.updateTag,
+  KnowledgeBaseOperation.deleteTag,
+  KnowledgeBaseOperation.getTagUsage,
+  KnowledgeBaseOperation.addConnector,
+  KnowledgeBaseOperation.updateConnector,
+  KnowledgeBaseOperation.deleteConnector,
+  KnowledgeBaseOperation.syncConnector,
+] as const
+
+export const ManageCredentialOperation = {
+  rename: 'rename',
+  delete: 'delete',
+} as const
+
+export type ManageCredentialOperation =
+  (typeof ManageCredentialOperation)[keyof typeof ManageCredentialOperation]
+
+export const ManageCredentialOperationValues = [
+  ManageCredentialOperation.rename,
+  ManageCredentialOperation.delete,
+] as const
+
+export const ManageCustomToolOperation = {
+  add: 'add',
+  edit: 'edit',
+  delete: 'delete',
+  list: 'list',
+} as const
+
+export type ManageCustomToolOperation =
+  (typeof ManageCustomToolOperation)[keyof typeof ManageCustomToolOperation]
+
+export const ManageCustomToolOperationValues = [
+  ManageCustomToolOperation.add,
+  ManageCustomToolOperation.edit,
+  ManageCustomToolOperation.delete,
+  ManageCustomToolOperation.list,
+] as const
+
+export const ManageJobOperation = {
+  create: 'create',
+  list: 'list',
+  get: 'get',
+  update: 'update',
+  delete: 'delete',
+} as const
+
+export type ManageJobOperation = (typeof ManageJobOperation)[keyof typeof ManageJobOperation]
+
+export const ManageJobOperationValues = [
+  ManageJobOperation.create,
+  ManageJobOperation.list,
+  ManageJobOperation.get,
+  ManageJobOperation.update,
+  ManageJobOperation.delete,
+] as const
+
+export const ManageMcpToolOperation = {
+  add: 'add',
+  edit: 'edit',
+  delete: 'delete',
+  list: 'list',
+} as const
+
+export type ManageMcpToolOperation =
+  (typeof ManageMcpToolOperation)[keyof typeof ManageMcpToolOperation]
+
+export const ManageMcpToolOperationValues = [
+  ManageMcpToolOperation.add,
+  ManageMcpToolOperation.edit,
+  ManageMcpToolOperation.delete,
+  ManageMcpToolOperation.list,
+] as const
+
+export const ManageSkillOperation = {
+  add: 'add',
+  edit: 'edit',
+  delete: 'delete',
+  list: 'list',
+} as const
+
+export type ManageSkillOperation = (typeof ManageSkillOperation)[keyof typeof ManageSkillOperation]
+
+export const ManageSkillOperationValues = [
+  ManageSkillOperation.add,
+  ManageSkillOperation.edit,
+  ManageSkillOperation.delete,
+  ManageSkillOperation.list,
+] as const
+
+export const MaterializeFileOperation = {
+  save: 'save',
+  import: 'import',
+  table: 'table',
+  knowledgeBase: 'knowledge_base',
+} as const
+
+export type MaterializeFileOperation =
+  (typeof MaterializeFileOperation)[keyof typeof MaterializeFileOperation]
+
+export const MaterializeFileOperationValues = [
+  MaterializeFileOperation.save,
+  MaterializeFileOperation.import,
+  MaterializeFileOperation.table,
+  MaterializeFileOperation.knowledgeBase,
+] as const
+
+export const UserMemoryOperation = {
+  add: 'add',
+  search: 'search',
+  delete: 'delete',
+  correct: 'correct',
+  list: 'list',
+} as const
+
+export type UserMemoryOperation = (typeof UserMemoryOperation)[keyof typeof UserMemoryOperation]
+
+export const UserMemoryOperationValues = [
+  UserMemoryOperation.add,
+  UserMemoryOperation.search,
+  UserMemoryOperation.delete,
+  UserMemoryOperation.correct,
+  UserMemoryOperation.list,
+] as const
+
+export const UserTableOperation = {
+  create: 'create',
+  createFromFile: 'create_from_file',
+  importFile: 'import_file',
+  get: 'get',
+  getSchema: 'get_schema',
+  delete: 'delete',
+  insertRow: 'insert_row',
+  batchInsertRows: 'batch_insert_rows',
+  getRow: 'get_row',
+  queryRows: 'query_rows',
+  updateRow: 'update_row',
+  deleteRow: 'delete_row',
+  updateRowsByFilter: 'update_rows_by_filter',
+  deleteRowsByFilter: 'delete_rows_by_filter',
+  batchUpdateRows: 'batch_update_rows',
+  batchDeleteRows: 'batch_delete_rows',
+  addColumn: 'add_column',
+  renameColumn: 'rename_column',
+  deleteColumn: 'delete_column',
+  updateColumn: 'update_column',
+} as const
+
+export type UserTableOperation = (typeof UserTableOperation)[keyof typeof UserTableOperation]
+
+export const UserTableOperationValues = [
+  UserTableOperation.create,
+  UserTableOperation.createFromFile,
+  UserTableOperation.importFile,
+  UserTableOperation.get,
+  UserTableOperation.getSchema,
+  UserTableOperation.delete,
+  UserTableOperation.insertRow,
+  UserTableOperation.batchInsertRows,
+  UserTableOperation.getRow,
+  UserTableOperation.queryRows,
+  UserTableOperation.updateRow,
+  UserTableOperation.deleteRow,
+  UserTableOperation.updateRowsByFilter,
+  UserTableOperation.deleteRowsByFilter,
+  UserTableOperation.batchUpdateRows,
+  UserTableOperation.batchDeleteRows,
+  UserTableOperation.addColumn,
+  UserTableOperation.renameColumn,
+  UserTableOperation.deleteColumn,
+  UserTableOperation.updateColumn,
+] as const
+
+export const WorkspaceFileOperation = {
+  append: 'append',
+  update: 'update',
+  patch: 'patch',
+} as const
+
+export type WorkspaceFileOperation =
+  (typeof WorkspaceFileOperation)[keyof typeof WorkspaceFileOperation]
+
+export const WorkspaceFileOperationValues = [
+  WorkspaceFileOperation.append,
+  WorkspaceFileOperation.update,
+  WorkspaceFileOperation.patch,
+] as const
+
+export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
+  [Agent.id]: Agent,
+  [Auth.id]: Auth,
+  [CheckDeploymentStatus.id]: CheckDeploymentStatus,
+  [CompleteJob.id]: CompleteJob,
+  [ContextWrite.id]: ContextWrite,
+  [CrawlWebsite.id]: CrawlWebsite,
+  [CreateFile.id]: CreateFile,
+  [CreateFolder.id]: CreateFolder,
+  [CreateJob.id]: CreateJob,
+  [CreateWorkflow.id]: CreateWorkflow,
+  [CreateWorkspaceMcpServer.id]: CreateWorkspaceMcpServer,
+  [DeleteFile.id]: DeleteFile,
+  [DeleteFolder.id]: DeleteFolder,
+  [DeleteWorkflow.id]: DeleteWorkflow,
+  [DeleteWorkspaceMcpServer.id]: DeleteWorkspaceMcpServer,
+  [Deploy.id]: Deploy,
+  [DeployApi.id]: DeployApi,
+  [DeployChat.id]: DeployChat,
+  [DeployMcp.id]: DeployMcp,
+  [DownloadToWorkspaceFile.id]: DownloadToWorkspaceFile,
+  [EditContent.id]: EditContent,
+  [EditWorkflow.id]: EditWorkflow,
+  [File.id]: File,
+  [FunctionExecute.id]: FunctionExecute,
+  [GenerateApiKey.id]: GenerateApiKey,
+  [GenerateImage.id]: GenerateImage,
+  [GenerateVisualization.id]: GenerateVisualization,
+  [GetBlockOutputs.id]: GetBlockOutputs,
+  [GetBlockUpstreamReferences.id]: GetBlockUpstreamReferences,
+  [GetDeployedWorkflowState.id]: GetDeployedWorkflowState,
+  [GetDeploymentVersion.id]: GetDeploymentVersion,
+  [GetExecutionSummary.id]: GetExecutionSummary,
+  [GetJobLogs.id]: GetJobLogs,
+  [GetPageContents.id]: GetPageContents,
+  [GetPlatformActions.id]: GetPlatformActions,
+  [GetWorkflowData.id]: GetWorkflowData,
+  [GetWorkflowLogs.id]: GetWorkflowLogs,
+  [Glob.id]: Glob,
+  [Grep.id]: Grep,
+  [Job.id]: Job,
+  [Knowledge.id]: Knowledge,
+  [KnowledgeBase.id]: KnowledgeBase,
+  [ListFolders.id]: ListFolders,
+  [ListUserWorkspaces.id]: ListUserWorkspaces,
+  [ListWorkspaceMcpServers.id]: ListWorkspaceMcpServers,
+  [ManageCredential.id]: ManageCredential,
+  [ManageCustomTool.id]: ManageCustomTool,
+  [ManageJob.id]: ManageJob,
+  [ManageMcpTool.id]: ManageMcpTool,
+  [ManageSkill.id]: ManageSkill,
+  [MaterializeFile.id]: MaterializeFile,
+  [MoveFolder.id]: MoveFolder,
+  [MoveWorkflow.id]: MoveWorkflow,
+  [OauthGetAuthLink.id]: OauthGetAuthLink,
+  [OauthRequestAccess.id]: OauthRequestAccess,
+  [OpenResource.id]: OpenResource,
+  [Read.id]: Read,
+  [Redeploy.id]: Redeploy,
+  [RenameFile.id]: RenameFile,
+  [RenameWorkflow.id]: RenameWorkflow,
+  [Research.id]: Research,
+  [Respond.id]: Respond,
+  [RestoreResource.id]: RestoreResource,
+  [RevertToVersion.id]: RevertToVersion,
+  [RunBlock.id]: RunBlock,
+  [RunFromBlock.id]: RunFromBlock,
+  [RunWorkflow.id]: RunWorkflow,
+  [RunWorkflowUntilBlock.id]: RunWorkflowUntilBlock,
+  [ScrapePage.id]: ScrapePage,
+  [SearchDocumentation.id]: SearchDocumentation,
+  [SearchLibraryDocs.id]: SearchLibraryDocs,
+  [SearchOnline.id]: SearchOnline,
+  [SearchPatterns.id]: SearchPatterns,
+  [SetBlockEnabled.id]: SetBlockEnabled,
+  [SetEnvironmentVariables.id]: SetEnvironmentVariables,
+  [SetGlobalWorkflowVariables.id]: SetGlobalWorkflowVariables,
+  [Superagent.id]: Superagent,
+  [Table.id]: Table,
+  [ToolSearchToolRegex.id]: ToolSearchToolRegex,
+  [UpdateJobHistory.id]: UpdateJobHistory,
+  [UpdateWorkspaceMcpServer.id]: UpdateWorkspaceMcpServer,
+  [UserMemory.id]: UserMemory,
+  [UserTable.id]: UserTable,
+  [Workflow.id]: Workflow,
+  [WorkspaceFile.id]: WorkspaceFile,
+}
diff --git a/apps/sim/lib/copilot/generated/tool-schemas-v1.ts b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
new file mode 100644
index 00000000000..7305d830f2f
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
@@ -0,0 +1,2859 @@
+// AUTO-GENERATED FILE. DO NOT EDIT.
+// Generated from copilot/contracts/tool-catalog-v1.json
+//
+
+export type JsonSchema = unknown
+
+export interface ToolRuntimeSchemaEntry {
+  parameters?: JsonSchema
+  resultSchema?: JsonSchema
+}
+
+export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
+  agent: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What tool/skill/MCP action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  auth: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What authentication/credential action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  check_deployment_status: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to check (defaults to current workflow)',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  complete_job: {
+    parameters: {
+      type: 'object',
+      properties: {
+        jobId: {
+          type: 'string',
+          description: 'The ID of the job to mark as completed.',
+        },
+      },
+      required: ['jobId'],
+    },
+    resultSchema: undefined,
+  },
+  context_write: {
+    parameters: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'Full content to write to the file (replaces existing content)',
+        },
+        file_path: {
+          type: 'string',
+          description: "Path of the file to write (e.g. 'SESSION.md')",
+        },
+      },
+      required: ['file_path', 'content'],
+    },
+    resultSchema: undefined,
+  },
+  crawl_website: {
+    parameters: {
+      type: 'object',
+      properties: {
+        exclude_paths: {
+          type: 'array',
+          description: 'Skip URLs matching these patterns',
+          items: {
+            type: 'string',
+          },
+        },
+        include_paths: {
+          type: 'array',
+          description: 'Only crawl URLs matching these patterns',
+          items: {
+            type: 'string',
+          },
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum pages to crawl (default 10, max 50)',
+        },
+        max_depth: {
+          type: 'number',
+          description: 'How deep to follow links (default 2)',
+        },
+        url: {
+          type: 'string',
+          description: 'Starting URL to crawl from',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  create_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        contentType: {
+          type: 'string',
+          description:
+            'Optional MIME type override. Usually omit and let the system infer from the file extension.',
+        },
+        fileName: {
+          type: 'string',
+          description:
+            'Plain workspace filename including extension, e.g. "main.py" or "report.md". Must not contain slashes.',
+        },
+      },
+      required: ['fileName'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Contains id (the fileId) and name.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the file was created.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  create_folder: {
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Folder name.',
+        },
+        parentId: {
+          type: 'string',
+          description: 'Optional parent folder ID.',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Optional workspace ID.',
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  create_job: {
+    parameters: {
+      type: 'object',
+      properties: {
+        cron: {
+          type: 'string',
+          description:
+            "Cron expression for recurring jobs (e.g., '*/5 * * * *' for every 5 minutes, '0 9 * * *' for daily at 9 AM). Omit for one-time jobs.",
+        },
+        lifecycle: {
+          type: 'string',
+          description:
+            "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called after the success condition is met.",
+          enum: ['persistent', 'until_complete'],
+        },
+        maxRuns: {
+          type: 'integer',
+          description:
+            'Maximum number of executions before the job auto-completes. Safety limit to prevent runaway polling.',
+        },
+        prompt: {
+          type: 'string',
+          description:
+            'The prompt to execute when the job fires. This is sent to the Mothership as a user message.',
+        },
+        successCondition: {
+          type: 'string',
+          description:
+            "What must happen for the job to be considered complete. Used with until_complete lifecycle (e.g., 'John has replied to the partnership email').",
+        },
+        time: {
+          type: 'string',
+          description:
+            "ISO 8601 datetime for one-time execution or as the start time for a cron schedule (e.g., '2026-03-06T09:00:00'). Include timezone offset or use the timezone parameter.",
+        },
+        timezone: {
+          type: 'string',
+          description:
+            "IANA timezone for the schedule (e.g., 'America/New_York', 'Europe/London'). Defaults to UTC.",
+        },
+        title: {
+          type: 'string',
+          description:
+            "A short, descriptive title for the job (e.g., 'Email Poller', 'Daily Report'). Used as the display name.",
+        },
+      },
+      required: ['title', 'prompt'],
+    },
+    resultSchema: undefined,
+  },
+  create_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        description: {
+          type: 'string',
+          description: 'Optional workflow description.',
+        },
+        folderId: {
+          type: 'string',
+          description: 'Optional folder ID.',
+        },
+        name: {
+          type: 'string',
+          description: 'Workflow name.',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Optional workspace ID.',
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  create_workspace_mcp_server: {
+    parameters: {
+      type: 'object',
+      properties: {
+        description: {
+          type: 'string',
+          description: 'Optional description for the server',
+        },
+        name: {
+          type: 'string',
+          description: 'Required: server name',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Workspace ID (defaults to current workspace)',
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  delete_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        fileIds: {
+          type: 'array',
+          description: 'Canonical workspace file IDs of the files to delete.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['fileIds'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the delete succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  delete_folder: {
+    parameters: {
+      type: 'object',
+      properties: {
+        folderIds: {
+          type: 'array',
+          description: 'The folder IDs to delete.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['folderIds'],
+    },
+    resultSchema: undefined,
+  },
+  delete_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowIds: {
+          type: 'array',
+          description: 'The workflow IDs to delete.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['workflowIds'],
+    },
+    resultSchema: undefined,
+  },
+  delete_workspace_mcp_server: {
+    parameters: {
+      type: 'object',
+      properties: {
+        serverId: {
+          type: 'string',
+          description: 'Required: the MCP server ID to delete',
+        },
+      },
+      required: ['serverId'],
+    },
+    resultSchema: undefined,
+  },
+  deploy: {
+    parameters: {
+      properties: {
+        request: {
+          description:
+            'Detailed deployment instructions. Include deployment type (api/chat) and ALL user-specified options: identifier, title, description, authType, password, allowedEmails, welcomeMessage, outputConfigs (block outputs to display).',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  deploy_api: {
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Whether to deploy or undeploy the API endpoint',
+          enum: ['deploy', 'undeploy'],
+          default: 'deploy',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to deploy (required in workspace context)',
+        },
+      },
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        apiEndpoint: {
+          type: 'string',
+          description: 'Canonical workflow execution endpoint.',
+        },
+        baseUrl: {
+          type: 'string',
+          description: 'Base URL used to construct deployment URLs.',
+        },
+        deployedAt: {
+          type: 'string',
+          description: 'Deployment timestamp when the workflow is deployed.',
+        },
+        deploymentConfig: {
+          type: 'object',
+          description:
+            'Structured deployment configuration keyed by surface name. For API deploys this includes endpoint, auth, and sync/stream/async mode details.',
+        },
+        deploymentStatus: {
+          type: 'object',
+          description:
+            'Structured per-surface deployment status keyed by surface name, such as api.',
+        },
+        deploymentType: {
+          type: 'string',
+          description:
+            'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+        },
+        examples: {
+          type: 'object',
+          description:
+            'Invocation examples keyed by surface name. For API deploys this includes curl examples for sync, stream, async, and polling.',
+        },
+        isDeployed: {
+          type: 'boolean',
+          description: 'Whether the workflow API is currently deployed after this tool call.',
+        },
+        version: {
+          type: 'number',
+          description: 'Deployment version for the current API deployment.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID that was deployed or undeployed.',
+        },
+      },
+      required: [
+        'workflowId',
+        'isDeployed',
+        'deploymentType',
+        'deploymentStatus',
+        'deploymentConfig',
+        'examples',
+      ],
+    },
+  },
+  deploy_chat: {
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Whether to deploy or undeploy the chat interface',
+          enum: ['deploy', 'undeploy'],
+          default: 'deploy',
+        },
+        allowedEmails: {
+          type: 'array',
+          description: 'List of allowed emails/domains for email or SSO auth',
+          items: {
+            type: 'string',
+          },
+        },
+        authType: {
+          type: 'string',
+          description: 'Authentication type: public, password, email, or sso',
+          enum: ['public', 'password', 'email', 'sso'],
+          default: 'public',
+        },
+        description: {
+          type: 'string',
+          description: 'Optional description for the chat',
+        },
+        identifier: {
+          type: 'string',
+          description: 'URL slug for the chat (lowercase letters, numbers, hyphens only)',
+        },
+        outputConfigs: {
+          type: 'array',
+          description: 'Output configurations specifying which block outputs to display in chat',
+          items: {
+            type: 'object',
+            properties: {
+              blockId: {
+                type: 'string',
+                description: 'The block UUID',
+              },
+              path: {
+                type: 'string',
+                description: "The output path (e.g. 'response', 'response.content')",
+              },
+            },
+            required: ['blockId', 'path'],
+          },
+        },
+        password: {
+          type: 'string',
+          description: 'Password for password-protected chats',
+        },
+        title: {
+          type: 'string',
+          description: 'Display title for the chat interface',
+        },
+        welcomeMessage: {
+          type: 'string',
+          description: 'Welcome message shown to users',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to deploy (required in workspace context)',
+        },
+      },
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Action performed by the tool, such as "deploy" or "undeploy".',
+        },
+        apiEndpoint: {
+          type: 'string',
+          description: 'Paired workflow execution endpoint used by the chat deployment.',
+        },
+        baseUrl: {
+          type: 'string',
+          description: 'Base URL used to construct deployment URLs.',
+        },
+        chatUrl: {
+          type: 'string',
+          description: 'Shareable chat URL when the chat surface is deployed.',
+        },
+        deployedAt: {
+          type: 'string',
+          description: 'Deployment timestamp for the underlying workflow deployment.',
+        },
+        deploymentConfig: {
+          type: 'object',
+          description:
+            'Structured deployment configuration keyed by surface name. Includes chat settings and the paired API invocation configuration.',
+        },
+        deploymentStatus: {
+          type: 'object',
+          description:
+            'Structured per-surface deployment status keyed by surface name, including api and chat.',
+        },
+        deploymentType: {
+          type: 'string',
+          description:
+            'Deployment surface this result describes. For deploy_chat this is always "chat".',
+        },
+        examples: {
+          type: 'object',
+          description:
+            'Invocation examples keyed by surface name. Includes chat access details and API curl examples.',
+        },
+        identifier: {
+          type: 'string',
+          description: 'Chat identifier or slug.',
+        },
+        isChatDeployed: {
+          type: 'boolean',
+          description: 'Whether the chat surface is deployed after this tool call.',
+        },
+        isDeployed: {
+          type: 'boolean',
+          description: 'Whether the paired API surface remains deployed after this tool call.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the deploy_chat action completed successfully.',
+        },
+        version: {
+          type: 'number',
+          description: 'Deployment version for the underlying workflow deployment.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID associated with the chat deployment.',
+        },
+      },
+      required: [
+        'workflowId',
+        'success',
+        'action',
+        'isDeployed',
+        'isChatDeployed',
+        'deploymentType',
+        'deploymentStatus',
+        'deploymentConfig',
+        'examples',
+      ],
+    },
+  },
+  deploy_mcp: {
+    parameters: {
+      type: 'object',
+      properties: {
+        parameterDescriptions: {
+          type: 'array',
+          description: 'Array of parameter descriptions for the tool',
+          items: {
+            type: 'object',
+            properties: {
+              description: {
+                type: 'string',
+                description: 'Parameter description',
+              },
+              name: {
+                type: 'string',
+                description: 'Parameter name',
+              },
+            },
+            required: ['name', 'description'],
+          },
+        },
+        serverId: {
+          type: 'string',
+          description: 'Required: server ID from list_workspace_mcp_servers',
+        },
+        toolDescription: {
+          type: 'string',
+          description: 'Description for the MCP tool',
+        },
+        toolName: {
+          type: 'string',
+          description: 'Name for the MCP tool (defaults to workflow name)',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID (defaults to active workflow)',
+        },
+      },
+      required: ['serverId'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Action performed by the tool, such as "deploy" or "undeploy".',
+        },
+        apiEndpoint: {
+          type: 'string',
+          description: 'Underlying workflow API endpoint associated with the MCP tool.',
+        },
+        baseUrl: {
+          type: 'string',
+          description: 'Base URL used to construct deployment URLs.',
+        },
+        deploymentConfig: {
+          type: 'object',
+          description:
+            'Structured deployment configuration keyed by surface name. Includes MCP server, tool, auth, and parameter schema details.',
+        },
+        deploymentStatus: {
+          type: 'object',
+          description:
+            'Structured per-surface deployment status keyed by surface name, including mcp and the underlying api surface when applicable.',
+        },
+        deploymentType: {
+          type: 'string',
+          description:
+            'Deployment surface this result describes. For deploy_mcp this is always "mcp".',
+        },
+        examples: {
+          type: 'object',
+          description:
+            'Setup examples keyed by surface name. Includes ready-to-paste config snippets for supported MCP clients.',
+        },
+        mcpServerUrl: {
+          type: 'string',
+          description: 'HTTP MCP server URL to configure in clients.',
+        },
+        removed: {
+          type: 'boolean',
+          description: 'Whether the MCP deployment was removed during an undeploy action.',
+        },
+        serverId: {
+          type: 'string',
+          description: 'Workspace MCP server ID.',
+        },
+        serverName: {
+          type: 'string',
+          description: 'Workspace MCP server name.',
+        },
+        toolDescription: {
+          type: 'string',
+          description: 'MCP tool description exposed on the server.',
+        },
+        toolId: {
+          type: 'string',
+          description: 'MCP tool ID when deployed.',
+        },
+        toolName: {
+          type: 'string',
+          description: 'MCP tool name exposed on the server.',
+        },
+        updated: {
+          type: 'boolean',
+          description: 'Whether an existing MCP tool deployment was updated instead of created.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID associated with the MCP deployment.',
+        },
+      },
+      required: ['deploymentType', 'deploymentStatus'],
+    },
+  },
+  download_to_workspace_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        fileName: {
+          type: 'string',
+          description:
+            'Optional workspace file name to save as. If omitted, the name is inferred from the response or URL.',
+        },
+        url: {
+          type: 'string',
+          description:
+            'Direct URL of the file to download, such as an image CDN URL ending in .png or .jpg',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  edit_content: {
+    parameters: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description:
+            'The text content to write. For append: text to append. For update: full replacement text. For patch with search_replace: the replacement text. For patch with anchored: the insert/replacement text.',
+        },
+      },
+      required: ['content'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description:
+            'Optional operation metadata such as file id, file name, size, and content type.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable summary of the outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the content was applied successfully.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  edit_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        operations: {
+          type: 'array',
+          description: 'Array of edit operations',
+          items: {
+            type: 'object',
+            properties: {
+              block_id: {
+                type: 'string',
+                description:
+                  'Block ID for the operation. For add operations, this will be the desired ID for the new block.',
+              },
+              operation_type: {
+                type: 'string',
+                description: 'Type of operation to perform',
+                enum: ['add', 'edit', 'delete', 'insert_into_subflow', 'extract_from_subflow'],
+              },
+              params: {
+                type: 'object',
+                description:
+                  'Parameters for the operation. \nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "gpt-4o"}}\nFor delete: {} (empty object)',
+              },
+            },
+            required: ['operation_type', 'block_id', 'params'],
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to edit. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['operations'],
+    },
+    resultSchema: undefined,
+  },
+  file: {
+    parameters: {
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  function_execute: {
+    parameters: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'string',
+          description:
+            'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with access to pre-installed CLI tools and workspace env vars as $VAR_NAME.',
+        },
+        inputFiles: {
+          type: 'array',
+          description:
+            'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}. Example: ["wf_123"]',
+          items: {
+            type: 'string',
+          },
+        },
+        inputTables: {
+          type: 'array',
+          description:
+            'Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Example: ["tbl_abc123"]',
+          items: {
+            type: 'string',
+          },
+        },
+        language: {
+          type: 'string',
+          description: 'Execution language.',
+          enum: ['javascript', 'python', 'shell'],
+        },
+        outputFormat: {
+          type: 'string',
+          description:
+            'Format for outputPath. Determines how the code result is serialized. If omitted, inferred from outputPath file extension.',
+          enum: ['json', 'csv', 'txt', 'md', 'html'],
+        },
+        outputMimeType: {
+          type: 'string',
+          description:
+            'MIME type for outputSandboxPath export. Required for binary files: image/png, image/jpeg, application/pdf, etc. Omit for text files.',
+        },
+        outputPath: {
+          type: 'string',
+          description:
+            'Pipe output directly to a NEW workspace file instead of returning in context. ALWAYS use this instead of a separate workspace_file write call. Use a flat path like "files/result.json" — nested paths are not supported.',
+        },
+        outputSandboxPath: {
+          type: 'string',
+          description:
+            'Path to a file created inside the sandbox that should be exported to the workspace. Use together with outputPath.',
+        },
+        outputTable: {
+          type: 'string',
+          description:
+            'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
+        },
+      },
+      required: ['code'],
+    },
+    resultSchema: undefined,
+  },
+  generate_api_key: {
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description:
+            "A descriptive name for the API key (e.g., 'production-key', 'dev-testing').",
+        },
+        workspaceId: {
+          type: 'string',
+          description: "Optional workspace ID. Defaults to user's default workspace.",
+        },
+      },
+      required: ['name'],
+    },
+    resultSchema: undefined,
+  },
+  generate_image: {
+    parameters: {
+      type: 'object',
+      properties: {
+        aspectRatio: {
+          type: 'string',
+          description: 'Aspect ratio for the generated image.',
+          enum: ['1:1', '16:9', '9:16', '4:3', '3:4'],
+        },
+        fileName: {
+          type: 'string',
+          description:
+            'Output file name. Defaults to "generated-image.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+        },
+        overwriteFileId: {
+          type: 'string',
+          description:
+            'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update, refine, or redo a previously generated image so the existing chat resource stays current instead of creating a duplicate like "image (1).png". The file ID is returned by previous generate_image or generate_visualization calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+        },
+        prompt: {
+          type: 'string',
+          description:
+            'Detailed text description of the image to generate, or editing instructions when used with editFileId.',
+        },
+        referenceFileIds: {
+          type: 'array',
+          description:
+            'File IDs of workspace images to include as context for the generation. All images are sent alongside the prompt. Use for: editing a single image (1 file), compositing multiple images together (2+ files), style transfer, face swapping, etc. Order matters — list the primary/base image first. When revising an existing image in place, pair the primary file ID here with overwriteFileId set to that same ID.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['prompt'],
+    },
+    resultSchema: undefined,
+  },
+  generate_visualization: {
+    parameters: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'string',
+          description:
+            "Python code that generates a visualization using matplotlib. MUST call plt.savefig('/home/user/output.png', dpi=150, bbox_inches='tight') to produce output.",
+        },
+        fileName: {
+          type: 'string',
+          description:
+            'Output file name. Defaults to "chart.png". Workspace files are flat, so pass a plain file name, not a nested path.',
+        },
+        inputFiles: {
+          type: 'array',
+          description:
+            'Canonical workspace file IDs to mount in the sandbox. Discover IDs via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json"). Mounted path: /home/user/files/{fileId}/{originalName}.',
+          items: {
+            type: 'string',
+          },
+        },
+        inputTables: {
+          type: 'array',
+          description:
+            "Table IDs to mount as CSV files in the sandbox. Each table appears at /home/user/tables/{tableId}.csv with a header row. Read with pandas: pd.read_csv('/home/user/tables/tbl_xxx.csv')",
+          items: {
+            type: 'string',
+          },
+        },
+        overwriteFileId: {
+          type: 'string',
+          description:
+            'If provided, overwrites the existing workspace file with this ID instead of creating a new file. Use this when the user asks to update, refine, or redo a previously generated chart so the existing chat resource stays current instead of creating a duplicate like "chart (1).png". The file ID is returned by previous generate_visualization or generate_image calls (fileId field), or can be found via read("files/by-id/{fileId}/meta.json").',
+        },
+      },
+      required: ['code'],
+    },
+    resultSchema: undefined,
+  },
+  get_block_outputs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        blockIds: {
+          type: 'array',
+          description:
+            'Optional array of block UUIDs. If provided, returns outputs only for those blocks. If not provided, returns outputs for all blocks in the workflow.',
+          items: {
+            type: 'string',
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  get_block_upstream_references: {
+    parameters: {
+      type: 'object',
+      properties: {
+        blockIds: {
+          type: 'array',
+          description:
+            'Required array of block UUIDs (minimum 1). Returns what each block can reference based on its position in the workflow graph.',
+          items: {
+            type: 'string',
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['blockIds'],
+    },
+    resultSchema: undefined,
+  },
+  get_deployed_workflow_state: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  get_deployment_version: {
+    parameters: {
+      type: 'object',
+      properties: {
+        version: {
+          type: 'number',
+          description: 'The deployment version number',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID',
+        },
+      },
+      required: ['workflowId', 'version'],
+    },
+    resultSchema: undefined,
+  },
+  get_execution_summary: {
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Max number of executions to return (default: 10, max: 20).',
+        },
+        status: {
+          type: 'string',
+          description: "Filter by status: 'success', 'error', or 'all' (default: 'all').",
+          enum: ['success', 'error', 'all'],
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If omitted, returns executions across all workflows in the workspace.',
+        },
+        workspaceId: {
+          type: 'string',
+          description: 'Workspace ID to scope executions to.',
+        },
+      },
+      required: ['workspaceId'],
+    },
+    resultSchema: undefined,
+  },
+  get_job_logs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        executionId: {
+          type: 'string',
+          description: 'Optional execution ID for a specific run.',
+        },
+        includeDetails: {
+          type: 'boolean',
+          description: 'Include tool calls, outputs, and cost details.',
+        },
+        jobId: {
+          type: 'string',
+          description: 'The job (schedule) ID to get logs for.',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max number of entries (default: 3, max: 5)',
+        },
+      },
+      required: ['jobId'],
+    },
+    resultSchema: undefined,
+  },
+  get_page_contents: {
+    parameters: {
+      type: 'object',
+      properties: {
+        include_highlights: {
+          type: 'boolean',
+          description: 'Include key highlights (default false)',
+        },
+        include_summary: {
+          type: 'boolean',
+          description: 'Include AI-generated summary (default false)',
+        },
+        include_text: {
+          type: 'boolean',
+          description: 'Include full page text (default true)',
+        },
+        urls: {
+          type: 'array',
+          description: 'URLs to get content from (max 10)',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['urls'],
+    },
+    resultSchema: undefined,
+  },
+  get_platform_actions: {
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+    resultSchema: undefined,
+  },
+  get_workflow_data: {
+    parameters: {
+      type: 'object',
+      properties: {
+        data_type: {
+          type: 'string',
+          description: 'The type of workflow data to retrieve',
+          enum: ['global_variables', 'custom_tools', 'mcp_tools', 'files'],
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['data_type'],
+    },
+    resultSchema: undefined,
+  },
+  get_workflow_logs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        executionId: {
+          type: 'string',
+          description:
+            'Optional execution ID to get logs for a specific execution. Use with get_execution_summary to find execution IDs first.',
+        },
+        includeDetails: {
+          type: 'boolean',
+          description: 'Include detailed info',
+        },
+        limit: {
+          type: 'number',
+          description: 'Max number of entries (hard limit: 3)',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  glob: {
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: {
+          type: 'string',
+          description:
+            'Glob pattern to match file paths. Supports * (any segment) and ** (any depth).',
+        },
+        toolTitle: {
+          type: 'string',
+          description:
+            'Optional target-only UI phrase for the search row. The UI verb is supplied for you, so pass text like "workflow configs" or "knowledge bases", not a full sentence like "Finding workflow configs".',
+        },
+      },
+      required: ['pattern', 'toolTitle'],
+    },
+    resultSchema: undefined,
+  },
+  grep: {
+    parameters: {
+      type: 'object',
+      properties: {
+        context: {
+          type: 'number',
+          description:
+            "Number of lines to show before and after each match. Only applies to output_mode 'content'.",
+        },
+        ignoreCase: {
+          type: 'boolean',
+          description: 'Case insensitive search (default false).',
+        },
+        lineNumbers: {
+          type: 'boolean',
+          description:
+            "Include line numbers in output (default true). Only applies to output_mode 'content'.",
+        },
+        maxResults: {
+          type: 'number',
+          description: 'Maximum number of matches to return (default 50).',
+        },
+        output_mode: {
+          type: 'string',
+          description:
+            "Output mode: 'content' shows matching lines (default), 'files_with_matches' shows only file paths, 'count' shows match counts per file.",
+          enum: ['content', 'files_with_matches', 'count'],
+        },
+        path: {
+          type: 'string',
+          description:
+            "Optional path prefix to scope the search (e.g. 'workflows/', 'environment/', 'internal/', 'components/blocks/').",
+        },
+        pattern: {
+          type: 'string',
+          description: 'Regex pattern to search for in file contents.',
+        },
+        toolTitle: {
+          type: 'string',
+          description:
+            'Optional target-only UI phrase for the search row. The UI verb is supplied for you, so pass text like "Slack integrations" or "deployed workflows", not a full sentence like "Searching for Slack integrations".',
+        },
+      },
+      required: ['pattern', 'toolTitle'],
+    },
+    resultSchema: undefined,
+  },
+  job: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What job action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  knowledge: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What knowledge base action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  knowledge_base: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            apiKey: {
+              type: 'string',
+              description:
+                'API key for API-key-based connectors (required when connector auth mode is apiKey)',
+            },
+            chunkingConfig: {
+              type: 'object',
+              description: "Chunking configuration (optional for 'create')",
+              properties: {
+                maxSize: {
+                  type: 'number',
+                  description: 'Maximum chunk size (100-4000, default: 1024)',
+                  default: 1024,
+                },
+                minSize: {
+                  type: 'number',
+                  description: 'Minimum chunk size (1-2000, default: 1)',
+                  default: 1,
+                },
+                overlap: {
+                  type: 'number',
+                  description: 'Overlap between chunks (0-500, default: 200)',
+                  default: 200,
+                },
+              },
+            },
+            connectorId: {
+              type: 'string',
+              description:
+                'Connector ID (required for update_connector, delete_connector, sync_connector)',
+            },
+            connectorStatus: {
+              type: 'string',
+              description: 'Connector status (optional for update_connector)',
+              enum: ['active', 'paused'],
+            },
+            connectorType: {
+              type: 'string',
+              description:
+                "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
+            },
+            credentialId: {
+              type: 'string',
+              description:
+                'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
+            },
+            description: {
+              type: 'string',
+              description: "Description of the knowledge base (optional for 'create')",
+            },
+            disabledTagIds: {
+              type: 'array',
+              description:
+                'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
+            },
+            documentId: {
+              type: 'string',
+              description: 'Document ID (required for update_document)',
+            },
+            documentIds: {
+              type: 'array',
+              description: 'Document IDs (for batch delete_document)',
+              items: {
+                type: 'string',
+              },
+            },
+            enabled: {
+              type: 'boolean',
+              description: 'Enable/disable a document (optional for update_document)',
+            },
+            fileIds: {
+              type: 'array',
+              description:
+                'Canonical workspace file IDs to add as documents (for add_file). Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+              items: {
+                type: 'string',
+              },
+            },
+            filename: {
+              type: 'string',
+              description: 'New filename for a document (optional for update_document)',
+            },
+            knowledgeBaseId: {
+              type: 'string',
+              description:
+                'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
+            },
+            knowledgeBaseIds: {
+              type: 'array',
+              description: 'Knowledge base IDs (for batch delete)',
+              items: {
+                type: 'string',
+              },
+            },
+            name: {
+              type: 'string',
+              description: "Name of the knowledge base (required for 'create')",
+            },
+            query: {
+              type: 'string',
+              description: "Search query text (required for 'query')",
+            },
+            sourceConfig: {
+              type: 'object',
+              description:
+                'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
+            },
+            syncIntervalMinutes: {
+              type: 'number',
+              description:
+                'Sync interval in minutes: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
+              default: 1440,
+            },
+            tagDefinitionId: {
+              type: 'string',
+              description: 'Tag definition ID (required for update_tag, delete_tag)',
+            },
+            tagDisplayName: {
+              type: 'string',
+              description:
+                'Display name for the tag (required for create_tag, optional for update_tag)',
+            },
+            tagFieldType: {
+              type: 'string',
+              description:
+                'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
+              enum: ['text', 'number', 'date', 'boolean'],
+            },
+            topK: {
+              type: 'number',
+              description: 'Number of results to return (1-50, default: 5)',
+              default: 5,
+            },
+            workspaceId: {
+              type: 'string',
+              description: "Workspace ID (required for 'create', optional filter for 'list')",
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform',
+          enum: [
+            'create',
+            'get',
+            'query',
+            'add_file',
+            'update',
+            'delete',
+            'delete_document',
+            'update_document',
+            'list_tags',
+            'create_tag',
+            'update_tag',
+            'delete_tag',
+            'get_tag_usage',
+            'add_connector',
+            'update_connector',
+            'delete_connector',
+            'sync_connector',
+          ],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  list_folders: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workspaceId: {
+          type: 'string',
+          description: 'Optional workspace ID to list folders for.',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  list_user_workspaces: {
+    parameters: {
+      type: 'object',
+      properties: {},
+    },
+    resultSchema: undefined,
+  },
+  list_workspace_mcp_servers: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workspaceId: {
+          type: 'string',
+          description: 'Workspace ID (defaults to current workspace)',
+        },
+      },
+    },
+    resultSchema: undefined,
+  },
+  manage_credential: {
+    parameters: {
+      type: 'object',
+      properties: {
+        credentialId: {
+          type: 'string',
+          description: 'The credential ID (required for rename)',
+        },
+        credentialIds: {
+          type: 'array',
+          description: 'Array of credential IDs (for batch delete)',
+          items: {
+            type: 'string',
+          },
+        },
+        displayName: {
+          type: 'string',
+          description: 'New display name (required for rename)',
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform',
+          enum: ['rename', 'delete'],
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  manage_custom_tool: {
+    parameters: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'string',
+          description:
+            'The JavaScript code that executes when the tool is called (required for add). Parameters from schema are available as variables. Function body only - no signature or wrapping braces.',
+        },
+        operation: {
+          type: 'string',
+          description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+          enum: ['add', 'edit', 'delete', 'list'],
+        },
+        schema: {
+          type: 'object',
+          description: 'The tool schema in OpenAI function calling format (required for add).',
+          properties: {
+            function: {
+              type: 'object',
+              description: 'The function definition',
+              properties: {
+                description: {
+                  type: 'string',
+                  description: 'What the function does',
+                },
+                name: {
+                  type: 'string',
+                  description: 'The function name (camelCase)',
+                },
+                parameters: {
+                  type: 'object',
+                  description: 'The function parameters schema',
+                  properties: {
+                    properties: {
+                      type: 'object',
+                      description: 'Parameter definitions as key-value pairs',
+                    },
+                    required: {
+                      type: 'array',
+                      description: 'Array of required parameter names',
+                      items: {
+                        type: 'string',
+                      },
+                    },
+                    type: {
+                      type: 'string',
+                      description: "Must be 'object'",
+                    },
+                  },
+                  required: ['type', 'properties'],
+                },
+              },
+              required: ['name', 'parameters'],
+            },
+            type: {
+              type: 'string',
+              description: "Must be 'function'",
+            },
+          },
+          required: ['type', 'function'],
+        },
+        toolId: {
+          type: 'string',
+          description:
+            "The ID of the custom tool (required for edit). Must be the exact toolId from the get_workflow_data custom tool response - do not guess or construct it. DO NOT PROVIDE THE TOOL ID IF THE OPERATION IS 'ADD'.",
+        },
+        toolIds: {
+          type: 'array',
+          description: 'Array of custom tool IDs (for batch delete)',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  manage_job: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description:
+            'Operation-specific arguments. For create: {title, prompt, cron?, time?, timezone?, lifecycle?, successCondition?, maxRuns?}. For get/delete: {jobId}. For update: {jobId, title?, prompt?, cron?, timezone?, status?, lifecycle?, successCondition?, maxRuns?}. For list: no args needed.',
+          properties: {
+            cron: {
+              type: 'string',
+              description: 'Cron expression for recurring jobs',
+            },
+            jobId: {
+              type: 'string',
+              description: 'Job ID (required for get, update)',
+            },
+            jobIds: {
+              type: 'array',
+              description: 'Array of job IDs (for batch delete)',
+              items: {
+                type: 'string',
+              },
+            },
+            lifecycle: {
+              type: 'string',
+              description:
+                "'persistent' (default) or 'until_complete'. Until_complete jobs stop when complete_job is called.",
+            },
+            maxRuns: {
+              type: 'integer',
+              description: 'Max executions before auto-completing. Safety limit.',
+            },
+            prompt: {
+              type: 'string',
+              description: 'The prompt to execute when the job fires',
+            },
+            status: {
+              type: 'string',
+              description: 'Job status: active, paused',
+            },
+            successCondition: {
+              type: 'string',
+              description:
+                'What must happen for the job to be considered complete (until_complete lifecycle).',
+            },
+            time: {
+              type: 'string',
+              description: 'ISO 8601 datetime for one-time jobs or cron start time',
+            },
+            timezone: {
+              type: 'string',
+              description: 'IANA timezone (e.g. America/New_York). Defaults to UTC.',
+            },
+            title: {
+              type: 'string',
+              description: "Short descriptive title for the job (e.g. 'Email Poller')",
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform: create, list, get, update, delete',
+          enum: ['create', 'list', 'get', 'update', 'delete'],
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  manage_mcp_tool: {
+    parameters: {
+      type: 'object',
+      properties: {
+        config: {
+          type: 'object',
+          description: 'Required for add and edit. The MCP server configuration.',
+          properties: {
+            enabled: {
+              type: 'boolean',
+              description: 'Whether the server is enabled (default: true)',
+            },
+            headers: {
+              type: 'object',
+              description: 'Optional HTTP headers to send with requests (key-value pairs)',
+            },
+            name: {
+              type: 'string',
+              description: 'Display name for the MCP server',
+            },
+            timeout: {
+              type: 'number',
+              description: 'Request timeout in milliseconds (default: 30000)',
+            },
+            transport: {
+              type: 'string',
+              description: "Transport protocol: 'streamable-http' or 'sse'",
+              enum: ['streamable-http', 'sse'],
+              default: 'streamable-http',
+            },
+            url: {
+              type: 'string',
+              description: 'The MCP server endpoint URL (required for add)',
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+          enum: ['add', 'edit', 'delete', 'list'],
+        },
+        serverId: {
+          type: 'string',
+          description:
+            "Required for edit and delete. The database ID of the MCP server. DO NOT PROVIDE if operation is 'add' or 'list'.",
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  manage_skill: {
+    parameters: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'Markdown instructions for the skill. Required for add, optional for edit.',
+        },
+        description: {
+          type: 'string',
+          description: 'Short description of the skill. Required for add, optional for edit.',
+        },
+        name: {
+          type: 'string',
+          description:
+            "Skill name in kebab-case (e.g. 'my-skill'). Required for add, optional for edit.",
+        },
+        operation: {
+          type: 'string',
+          description: "The operation to perform: 'add', 'edit', 'list', or 'delete'",
+          enum: ['add', 'edit', 'delete', 'list'],
+        },
+        skillId: {
+          type: 'string',
+          description:
+            "The ID of the skill (required for edit/delete). Must be the exact ID from the VFS or list. DO NOT PROVIDE if operation is 'add' or 'list'.",
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  materialize_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        fileNames: {
+          type: 'array',
+          description:
+            'The names of the uploaded files to materialize (e.g. ["report.pdf", "data.csv"])',
+          items: {
+            type: 'string',
+          },
+        },
+        knowledgeBaseId: {
+          type: 'string',
+          description:
+            'ID of an existing knowledge base to add the file to (only used with operation "knowledge_base"). If omitted, a new KB is created.',
+        },
+        operation: {
+          type: 'string',
+          description:
+            'What to do with the file. "save" promotes it to files/. "import" imports a workflow JSON. "table" converts CSV/TSV/JSON to a table. "knowledge_base" saves and adds to a KB. Defaults to "save".',
+          enum: ['save', 'import', 'table', 'knowledge_base'],
+          default: 'save',
+        },
+        tableName: {
+          type: 'string',
+          description:
+            'Custom name for the table (only used with operation "table"). Defaults to the file name without extension.',
+        },
+      },
+      required: ['fileNames'],
+    },
+    resultSchema: undefined,
+  },
+  move_folder: {
+    parameters: {
+      type: 'object',
+      properties: {
+        folderId: {
+          type: 'string',
+          description: 'The folder ID to move.',
+        },
+        parentId: {
+          type: 'string',
+          description:
+            'Target parent folder ID. Omit or pass empty string to move to workspace root.',
+        },
+      },
+      required: ['folderId'],
+    },
+    resultSchema: undefined,
+  },
+  move_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        folderId: {
+          type: 'string',
+          description: 'Target folder ID. Omit or pass empty string to move to workspace root.',
+        },
+        workflowIds: {
+          type: 'array',
+          description: 'The workflow IDs to move.',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['workflowIds'],
+    },
+    resultSchema: undefined,
+  },
+  oauth_get_auth_link: {
+    parameters: {
+      type: 'object',
+      properties: {
+        providerName: {
+          type: 'string',
+          description:
+            "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar', 'GitHub')",
+        },
+      },
+      required: ['providerName'],
+    },
+    resultSchema: undefined,
+  },
+  oauth_request_access: {
+    parameters: {
+      type: 'object',
+      properties: {
+        providerName: {
+          type: 'string',
+          description:
+            "The name of the OAuth provider to connect (e.g., 'Slack', 'Gmail', 'Google Calendar')",
+        },
+      },
+      required: ['providerName'],
+    },
+    resultSchema: undefined,
+  },
+  open_resource: {
+    parameters: {
+      type: 'object',
+      properties: {
+        resources: {
+          type: 'array',
+          description: 'Array of resources to open. Each item must have type and id.',
+          items: {
+            type: 'object',
+            properties: {
+              id: {
+                type: 'string',
+                description: 'The resource ID.',
+              },
+              type: {
+                type: 'string',
+                description: 'The resource type.',
+                enum: ['workflow', 'table', 'knowledgebase', 'file', 'log'],
+              },
+            },
+            required: ['type', 'id'],
+          },
+        },
+      },
+      required: ['resources'],
+    },
+    resultSchema: undefined,
+  },
+  read: {
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Maximum number of lines to read.',
+        },
+        offset: {
+          type: 'number',
+          description: 'Line offset to start reading from (0-indexed).',
+        },
+        outputTable: {
+          type: 'string',
+          description:
+            'Table ID to import the file contents into (CSV/JSON). All existing rows are replaced. Example: "tbl_abc123"',
+        },
+        path: {
+          type: 'string',
+          description: "Path to the file to read (e.g. 'workflows/My Workflow/state.json').",
+        },
+      },
+      required: ['path'],
+    },
+    resultSchema: undefined,
+  },
+  redeploy: {
+    parameters: {
+      type: 'object',
+      properties: {
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID to redeploy (required in workspace context)',
+        },
+      },
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        apiEndpoint: {
+          type: 'string',
+          description: 'Canonical workflow execution endpoint.',
+        },
+        baseUrl: {
+          type: 'string',
+          description: 'Base URL used to construct deployment URLs.',
+        },
+        deployedAt: {
+          type: 'string',
+          description: 'Deployment timestamp when the workflow is deployed.',
+        },
+        deploymentConfig: {
+          type: 'object',
+          description:
+            'Structured deployment configuration keyed by surface name. For API deploys this includes endpoint, auth, and sync/stream/async mode details.',
+        },
+        deploymentStatus: {
+          type: 'object',
+          description:
+            'Structured per-surface deployment status keyed by surface name, such as api.',
+        },
+        deploymentType: {
+          type: 'string',
+          description:
+            'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+        },
+        examples: {
+          type: 'object',
+          description:
+            'Invocation examples keyed by surface name. For API deploys this includes curl examples for sync, stream, async, and polling.',
+        },
+        isDeployed: {
+          type: 'boolean',
+          description: 'Whether the workflow API is currently deployed after this tool call.',
+        },
+        version: {
+          type: 'number',
+          description: 'Deployment version for the current API deployment.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID that was deployed or undeployed.',
+        },
+      },
+      required: [
+        'workflowId',
+        'isDeployed',
+        'deploymentType',
+        'deploymentStatus',
+        'deploymentConfig',
+        'examples',
+      ],
+    },
+  },
+  rename_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        fileId: {
+          type: 'string',
+          description: 'Canonical workspace file ID of the file to rename.',
+        },
+        newName: {
+          type: 'string',
+          description:
+            'New filename including extension, e.g. "draft_v2.md". Must not contain slashes.',
+        },
+      },
+      required: ['fileId', 'newName'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Contains id and the new name.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the rename succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  rename_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          description: 'The new name for the workflow.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID to rename.',
+        },
+      },
+      required: ['workflowId', 'name'],
+    },
+    resultSchema: undefined,
+  },
+  research: {
+    parameters: {
+      properties: {
+        topic: {
+          description: 'The topic to research.',
+          type: 'string',
+        },
+      },
+      required: ['topic'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  respond: {
+    parameters: {
+      additionalProperties: true,
+      properties: {
+        output: {
+          description:
+            'The result — facts, status, VFS paths to persisted data, whatever the caller needs to act on.',
+          type: 'string',
+        },
+        success: {
+          description: 'Whether the task completed successfully',
+          type: 'boolean',
+        },
+        type: {
+          description: 'Optional logical result type override',
+          type: 'string',
+        },
+      },
+      required: ['output', 'success'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  restore_resource: {
+    parameters: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string',
+          description: 'The canonical resource ID to restore.',
+        },
+        type: {
+          type: 'string',
+          description: 'The resource type to restore.',
+          enum: ['workflow', 'table', 'file', 'knowledgebase', 'folder'],
+        },
+      },
+      required: ['type', 'id'],
+    },
+    resultSchema: undefined,
+  },
+  revert_to_version: {
+    parameters: {
+      type: 'object',
+      properties: {
+        version: {
+          type: 'number',
+          description: 'The deployment version number to revert to',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'The workflow ID',
+        },
+      },
+      required: ['workflowId', 'version'],
+    },
+    resultSchema: undefined,
+  },
+  run_block: {
+    parameters: {
+      type: 'object',
+      properties: {
+        blockId: {
+          type: 'string',
+          description: 'The block ID to run in isolation.',
+        },
+        executionId: {
+          type: 'string',
+          description:
+            'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+        },
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['blockId'],
+    },
+    resultSchema: undefined,
+  },
+  run_from_block: {
+    parameters: {
+      type: 'object',
+      properties: {
+        executionId: {
+          type: 'string',
+          description:
+            'Optional execution ID to load the snapshot from. Uses latest execution if omitted.',
+        },
+        startBlockId: {
+          type: 'string',
+          description: 'The block ID to start execution from.',
+        },
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['startBlockId'],
+    },
+    resultSchema: undefined,
+  },
+  run_workflow: {
+    parameters: {
+      type: 'object',
+      properties: {
+        triggerBlockId: {
+          type: 'string',
+          description:
+            'Optional trigger block ID when the workflow has multiple entrypoints and you need to target a specific one.',
+        },
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['workflow_input'],
+    },
+    resultSchema: undefined,
+  },
+  run_workflow_until_block: {
+    parameters: {
+      type: 'object',
+      properties: {
+        stopAfterBlockId: {
+          type: 'string',
+          description: 'The block ID to stop after. Execution halts once this block completes.',
+        },
+        triggerBlockId: {
+          type: 'string',
+          description:
+            'Optional trigger block ID when the workflow has multiple entrypoints and you need to target a specific one.',
+        },
+        useDeployedState: {
+          type: 'boolean',
+          description:
+            'When true, runs the deployed version instead of the live draft. Default: false (draft).',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+        },
+        workflow_input: {
+          type: 'object',
+          description: 'JSON object with key-value mappings where each key is an input field name',
+        },
+      },
+      required: ['stopAfterBlockId'],
+    },
+    resultSchema: undefined,
+  },
+  scrape_page: {
+    parameters: {
+      type: 'object',
+      properties: {
+        include_links: {
+          type: 'boolean',
+          description: 'Extract all links from the page (default false)',
+        },
+        url: {
+          type: 'string',
+          description: 'The URL to scrape (must include https://)',
+        },
+        wait_for: {
+          type: 'string',
+          description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  search_documentation: {
+    parameters: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'The search query',
+        },
+        topK: {
+          type: 'number',
+          description: 'Number of results (max 10)',
+        },
+      },
+      required: ['query'],
+    },
+    resultSchema: undefined,
+  },
+  search_library_docs: {
+    parameters: {
+      type: 'object',
+      properties: {
+        library_name: {
+          type: 'string',
+          description: "Name of the library to search for (e.g., 'nextjs', 'stripe', 'langchain')",
+        },
+        query: {
+          type: 'string',
+          description: 'The question or topic to find documentation for - be specific',
+        },
+        version: {
+          type: 'string',
+          description: "Specific version (optional, e.g., '14', 'v2')",
+        },
+      },
+      required: ['library_name', 'query'],
+    },
+    resultSchema: undefined,
+  },
+  search_online: {
+    parameters: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          description: 'Filter by category',
+          enum: [
+            'news',
+            'tweet',
+            'github',
+            'paper',
+            'company',
+            'research paper',
+            'linkedin profile',
+            'pdf',
+            'personal site',
+          ],
+        },
+        include_text: {
+          type: 'boolean',
+          description: 'Include page text content (default true)',
+        },
+        num_results: {
+          type: 'number',
+          description: 'Number of results (default 10, max 25)',
+        },
+        query: {
+          type: 'string',
+          description: 'Natural language search query',
+        },
+        toolTitle: {
+          type: 'string',
+          description:
+            'Optional target-only UI phrase for the search row. The UI verb is supplied for you, so pass text like "pricing changes" or "Slack webhook docs", not a full sentence like "Searching online for pricing changes".',
+        },
+      },
+      required: ['query', 'toolTitle'],
+    },
+    resultSchema: undefined,
+  },
+  search_patterns: {
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'integer',
+          description: 'Maximum number of unique pattern examples to return (defaults to 3).',
+        },
+        queries: {
+          type: 'array',
+          description:
+            'Up to 3 descriptive strings explaining the workflow pattern(s) you need. Focus on intent and desired outcomes.',
+          items: {
+            type: 'string',
+            description: 'Example: "how to automate wealthbox meeting notes into follow-up tasks"',
+          },
+        },
+      },
+      required: ['queries'],
+    },
+    resultSchema: undefined,
+  },
+  set_block_enabled: {
+    parameters: {
+      type: 'object',
+      properties: {
+        blockId: {
+          type: 'string',
+          description: 'The block ID whose enabled state should be changed.',
+        },
+        enabled: {
+          type: 'boolean',
+          description: 'Set to true to enable the block, or false to disable it.',
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID to edit. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['blockId', 'enabled'],
+    },
+    resultSchema: undefined,
+  },
+  set_environment_variables: {
+    parameters: {
+      type: 'object',
+      properties: {
+        variables: {
+          type: 'array',
+          description: 'List of env vars to set',
+          items: {
+            type: 'object',
+            properties: {
+              name: {
+                type: 'string',
+                description: 'Variable name',
+              },
+              value: {
+                type: 'string',
+                description: 'Variable value',
+              },
+            },
+            required: ['name', 'value'],
+          },
+        },
+      },
+      required: ['variables'],
+    },
+    resultSchema: undefined,
+  },
+  set_global_workflow_variables: {
+    parameters: {
+      type: 'object',
+      properties: {
+        operations: {
+          type: 'array',
+          description: 'List of operations to apply',
+          items: {
+            type: 'object',
+            properties: {
+              name: {
+                type: 'string',
+              },
+              operation: {
+                type: 'string',
+                enum: ['add', 'delete', 'edit'],
+              },
+              type: {
+                type: 'string',
+                enum: ['plain', 'number', 'boolean', 'array', 'object'],
+              },
+              value: {
+                type: 'string',
+              },
+            },
+            required: ['operation', 'name', 'type', 'value'],
+          },
+        },
+        workflowId: {
+          type: 'string',
+          description:
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
+        },
+      },
+      required: ['operations'],
+    },
+    resultSchema: undefined,
+  },
+  superagent: {
+    parameters: {
+      properties: {
+        task: {
+          description:
+            "A single sentence — the agent has full conversation context. Do NOT pre-read credentials or look up configs. Example: 'send the email we discussed' or 'check my calendar for tomorrow'.",
+          type: 'string',
+        },
+      },
+      required: ['task'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  table: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What table action is needed.',
+          type: 'string',
+        },
+      },
+      required: ['request'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  tool_search_tool_regex: {
+    parameters: {
+      properties: {
+        case_insensitive: {
+          description: 'Whether the regex should be case-insensitive (default true).',
+          type: 'boolean',
+        },
+        max_results: {
+          description: 'Maximum number of tools to return (optional).',
+          type: 'integer',
+        },
+        pattern: {
+          description: 'Regular expression to match tool names or descriptions.',
+          type: 'string',
+        },
+      },
+      required: ['pattern'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  update_job_history: {
+    parameters: {
+      type: 'object',
+      properties: {
+        jobId: {
+          type: 'string',
+          description: 'The job ID.',
+        },
+        summary: {
+          type: 'string',
+          description:
+            "A concise summary of what was done this run (e.g., 'Sent follow-up emails to 3 leads: Alice, Bob, Carol').",
+        },
+      },
+      required: ['jobId', 'summary'],
+    },
+    resultSchema: undefined,
+  },
+  update_workspace_mcp_server: {
+    parameters: {
+      type: 'object',
+      properties: {
+        description: {
+          type: 'string',
+          description: 'New description for the server',
+        },
+        isPublic: {
+          type: 'boolean',
+          description: 'Whether the server is publicly accessible',
+        },
+        name: {
+          type: 'string',
+          description: 'New name for the server',
+        },
+        serverId: {
+          type: 'string',
+          description: 'Required: the MCP server ID to update',
+        },
+      },
+      required: ['serverId'],
+    },
+    resultSchema: undefined,
+  },
+  user_memory: {
+    parameters: {
+      type: 'object',
+      properties: {
+        confidence: {
+          type: 'number',
+          description: 'Confidence level 0-1 (default 1.0 for explicit, 0.8 for inferred)',
+        },
+        correct_value: {
+          type: 'string',
+          description: "The correct value to replace the wrong one (for 'correct' operation)",
+        },
+        key: {
+          type: 'string',
+          description: "Unique key for the memory (e.g., 'preferred_model', 'slack_credential')",
+        },
+        limit: {
+          type: 'number',
+          description: 'Number of results for search (default 10)',
+        },
+        memory_type: {
+          type: 'string',
+          description: "Type of memory: 'preference', 'entity', 'history', or 'correction'",
+          enum: ['preference', 'entity', 'history', 'correction'],
+        },
+        operation: {
+          type: 'string',
+          description: "Operation: 'add', 'search', 'delete', 'correct', or 'list'",
+          enum: ['add', 'search', 'delete', 'correct', 'list'],
+        },
+        query: {
+          type: 'string',
+          description: 'Search query to find relevant memories',
+        },
+        source: {
+          type: 'string',
+          description: "Source: 'explicit' (user told you) or 'inferred' (you observed)",
+          enum: ['explicit', 'inferred'],
+        },
+        value: {
+          type: 'string',
+          description: 'Value to remember',
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: undefined,
+  },
+  user_table: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            column: {
+              type: 'object',
+              description: 'Column definition for add_column: { name, type, unique?, position? }',
+            },
+            columnName: {
+              type: 'string',
+              description:
+                'Column name (required for rename_column, update_column; use columnNames array for batch delete_column)',
+            },
+            columnNames: {
+              type: 'array',
+              description:
+                'Array of column names to delete at once (for delete_column). Preferred over columnName when deleting multiple columns.',
+            },
+            data: {
+              type: 'object',
+              description: 'Row data as key-value pairs (required for insert_row, update_row)',
+            },
+            description: {
+              type: 'string',
+              description: "Table description (optional for 'create')",
+            },
+            fileId: {
+              type: 'string',
+              description:
+                'Canonical workspace file ID for create_from_file/import_file. Discover via read("files/{name}/meta.json") or glob("files/by-id/*/meta.json").',
+            },
+            filePath: {
+              type: 'string',
+              description:
+                'Legacy workspace file reference for create_from_file/import_file. Prefer fileId.',
+            },
+            filter: {
+              type: 'object',
+              description:
+                'MongoDB-style filter for query_rows, update_rows_by_filter, delete_rows_by_filter',
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum rows to return or affect (optional, default 100)',
+            },
+            name: {
+              type: 'string',
+              description: "Table name (required for 'create')",
+            },
+            newName: {
+              type: 'string',
+              description: 'New column name (required for rename_column)',
+            },
+            newType: {
+              type: 'string',
+              description:
+                'New column type (optional for update_column). Types: string, number, boolean, date, json',
+            },
+            offset: {
+              type: 'number',
+              description: 'Number of rows to skip (optional for query_rows, default 0)',
+            },
+            outputFormat: {
+              type: 'string',
+              description:
+                'Explicit format override for outputPath. Usually unnecessary — the file extension determines the format automatically. Only use this to force a different format than what the extension implies.',
+              enum: ['json', 'csv', 'txt', 'md', 'html'],
+            },
+            outputPath: {
+              type: 'string',
+              description:
+                'Pipe query_rows results directly to a NEW workspace file. The format is auto-inferred from the file extension: .csv → CSV, .json → JSON, .md → Markdown, etc. Use .csv for tabular exports. Use a flat path like "files/export.csv" — nested paths are not supported.',
+            },
+            rowId: {
+              type: 'string',
+              description: 'Row ID (required for get_row, update_row, delete_row)',
+            },
+            rowIds: {
+              type: 'array',
+              description: 'Array of row IDs to delete (for batch_delete_rows)',
+            },
+            rows: {
+              type: 'array',
+              description: 'Array of row data objects (required for batch_insert_rows)',
+            },
+            schema: {
+              type: 'object',
+              description:
+                "Table schema with columns array (required for 'create'). Each column: { name, type, unique? }",
+            },
+            sort: {
+              type: 'object',
+              description:
+                "Sort specification as { field: 'asc' | 'desc' } (optional for query_rows)",
+            },
+            tableId: {
+              type: 'string',
+              description:
+                "Table ID (required for most operations except 'create' and batch 'delete')",
+            },
+            tableIds: {
+              type: 'array',
+              description: 'Array of table IDs (for batch delete)',
+              items: {
+                type: 'string',
+              },
+            },
+            unique: {
+              type: 'boolean',
+              description: 'Set column unique constraint (optional for update_column)',
+            },
+            updates: {
+              type: 'array',
+              description:
+                'Array of per-row updates: [{ rowId, data: { col: val } }] (for batch_update_rows)',
+            },
+            values: {
+              type: 'object',
+              description:
+                'Map of rowId to value for single-column batch update: { "rowId1": val1, "rowId2": val2 } (for batch_update_rows with columnName)',
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform',
+          enum: [
+            'create',
+            'create_from_file',
+            'import_file',
+            'get',
+            'get_schema',
+            'delete',
+            'insert_row',
+            'batch_insert_rows',
+            'get_row',
+            'query_rows',
+            'update_row',
+            'delete_row',
+            'update_rows_by_filter',
+            'delete_rows_by_filter',
+            'batch_update_rows',
+            'batch_delete_rows',
+            'add_column',
+            'rename_column',
+            'delete_column',
+            'update_column',
+          ],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  workflow: {
+    parameters: {
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  workspace_file: {
+    parameters: {
+      type: 'object',
+      properties: {
+        operation: {
+          type: 'string',
+          description: 'The file operation to perform.',
+          enum: ['append', 'update', 'patch'],
+        },
+        target: {
+          type: 'object',
+          description: 'Explicit file target. Use kind=file_id + fileId for existing files.',
+          properties: {
+            fileId: {
+              type: 'string',
+              description:
+                'Canonical existing workspace file ID. Required when target.kind=file_id.',
+            },
+            fileName: {
+              type: 'string',
+              description:
+                'Plain workspace filename including extension, e.g. "main.py" or "report.docx". Required when target.kind=new_file.',
+            },
+            kind: {
+              type: 'string',
+              description: 'How the file target is identified.',
+              enum: ['new_file', 'file_id'],
+            },
+          },
+          required: ['kind'],
+        },
+        title: {
+          type: 'string',
+          description:
+            'Required short UI label for this content unit, e.g. "Chapter 1", "Slide 3", or "Fix footer spacing".',
+        },
+        contentType: {
+          type: 'string',
+          description:
+            'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
+          enum: [
+            'text/markdown',
+            'text/html',
+            'text/plain',
+            'application/json',
+            'text/csv',
+            'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'application/pdf',
+          ],
+        },
+        edit: {
+          type: 'object',
+          description:
+            'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. The actual replacement/insert content is provided via the paired edit_content tool call.',
+          properties: {
+            after_anchor: {
+              type: 'string',
+              description:
+                'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
+            },
+            anchor: {
+              type: 'string',
+              description:
+                'Anchor line after which new content is inserted. Required for mode=insert_after.',
+            },
+            before_anchor: {
+              type: 'string',
+              description:
+                'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
+            },
+            end_anchor: {
+              type: 'string',
+              description: 'First line to keep after deletion. Required for mode=delete_between.',
+            },
+            mode: {
+              type: 'string',
+              description: 'Anchored edit mode when strategy=anchored.',
+              enum: ['replace_between', 'insert_after', 'delete_between'],
+            },
+            occurrence: {
+              type: 'number',
+              description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
+            },
+            replaceAll: {
+              type: 'boolean',
+              description:
+                'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
+            },
+            search: {
+              type: 'string',
+              description:
+                'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
+            },
+            start_anchor: {
+              type: 'string',
+              description: 'First line to delete. Required for mode=delete_between.',
+            },
+            strategy: {
+              type: 'string',
+              description: 'Patch strategy.',
+              enum: ['search_replace', 'anchored'],
+            },
+          },
+        },
+        newName: {
+          type: 'string',
+          description:
+            'New file name for rename. Must be a plain workspace filename like "main.py".',
+        },
+      },
+      required: ['operation', 'target', 'title'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description:
+            'Optional operation metadata such as file id, file name, size, and content type.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable summary of the outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the file operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+}
diff --git a/apps/sim/lib/copilot/logging.ts b/apps/sim/lib/copilot/logging.ts
deleted file mode 100644
index b1f0aa90435..00000000000
--- a/apps/sim/lib/copilot/logging.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-export interface CopilotLogContext {
-  requestId?: string
-  messageId?: string
-}
-
-/**
- * Appends copilot request identifiers to a log message.
- */
-export function appendCopilotLogContext(message: string, context: CopilotLogContext = {}): string {
-  const suffixParts: string[] = []
-
-  if (context.requestId) {
-    suffixParts.push(`requestId:${context.requestId}`)
-  }
-
-  if (context.messageId) {
-    suffixParts.push(`messageId:${context.messageId}`)
-  }
-
-  if (suffixParts.length === 0) {
-    return message
-  }
-
-  return `${message} [${suffixParts.join(' ')}]`
-}
diff --git a/apps/sim/lib/copilot/models.ts b/apps/sim/lib/copilot/models.ts
deleted file mode 100644
index f102de517f1..00000000000
--- a/apps/sim/lib/copilot/models.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-export type CopilotModelId = string
-
-export const COPILOT_MODES = ['ask', 'build', 'plan'] as const
-export type CopilotMode = (typeof COPILOT_MODES)[number]
-
-export const COPILOT_TRANSPORT_MODES = ['ask', 'agent', 'plan'] as const
-export type CopilotTransportMode = (typeof COPILOT_TRANSPORT_MODES)[number]
-
-export const COPILOT_REQUEST_MODES = ['ask', 'build', 'plan', 'agent'] as const
-export type CopilotRequestMode = (typeof COPILOT_REQUEST_MODES)[number]
diff --git a/apps/sim/lib/copilot/orchestrator/index.ts b/apps/sim/lib/copilot/orchestrator/index.ts
deleted file mode 100644
index 5893ce7bb4f..00000000000
--- a/apps/sim/lib/copilot/orchestrator/index.ts
+++ /dev/null
@@ -1,571 +0,0 @@
-import { createLogger } from '@sim/logger'
-import {
-  ASYNC_TOOL_STATUS,
-  inferDeliveredAsyncSuccess,
-  isDeliveredAsyncStatus,
-  isTerminalAsyncStatus,
-} from '@/lib/copilot/async-runs/lifecycle'
-import {
-  claimCompletedAsyncToolCall,
-  getAsyncToolCall,
-  getAsyncToolCalls,
-  markAsyncToolDelivered,
-  releaseCompletedAsyncToolClaim,
-  updateRunStatus,
-} from '@/lib/copilot/async-runs/repository'
-import { SIM_AGENT_API_URL, SIM_AGENT_VERSION } from '@/lib/copilot/constants'
-import {
-  isToolAvailableOnSimSide,
-  prepareExecutionContext,
-} from '@/lib/copilot/orchestrator/tool-executor'
-import {
-  type ExecutionContext,
-  isTerminalToolCallStatus,
-  type OrchestratorOptions,
-  type OrchestratorResult,
-  type SSEEvent,
-  type ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { env } from '@/lib/core/config/env'
-import { generateId } from '@/lib/core/utils/uuid'
-import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { buildToolCallSummaries, createStreamingContext, runStreamLoop } from './stream/core'
-
-const logger = createLogger('CopilotOrchestrator')
-
-function didAsyncToolSucceed(input: {
-  durableStatus?: string | null
-  durableResult?: Record<string, unknown>
-  durableError?: string | null
-  toolStateStatus?: string | undefined
-}) {
-  const { durableStatus, durableResult, durableError, toolStateStatus } = input
-
-  if (durableStatus === ASYNC_TOOL_STATUS.completed) {
-    return true
-  }
-  if (durableStatus === ASYNC_TOOL_STATUS.failed || durableStatus === ASYNC_TOOL_STATUS.cancelled) {
-    return false
-  }
-
-  if (durableStatus === ASYNC_TOOL_STATUS.delivered) {
-    return inferDeliveredAsyncSuccess({
-      result: durableResult,
-      error: durableError,
-    })
-  }
-
-  if (toolStateStatus === 'success') return true
-  if (toolStateStatus === 'error' || toolStateStatus === 'cancelled') return false
-
-  return false
-}
-
-interface ReadyContinuationTool {
-  toolCallId: string
-  toolState?: ToolCallState
-  durableRow?: Awaited<ReturnType<typeof getAsyncToolCall>>
-  needsDurableClaim: boolean
-  alreadyClaimedByWorker: boolean
-}
-
-export interface OrchestrateStreamOptions extends OrchestratorOptions {
-  userId: string
-  workflowId?: string
-  workspaceId?: string
-  chatId?: string
-  executionId?: string
-  runId?: string
-  /** Go-side route to proxy to. Defaults to '/api/copilot'. */
-  goRoute?: string
-}
-
-export async function orchestrateCopilotStream(
-  requestPayload: Record<string, unknown>,
-  options: OrchestrateStreamOptions
-): Promise<OrchestratorResult> {
-  const {
-    userId,
-    workflowId,
-    workspaceId,
-    chatId,
-    executionId,
-    runId,
-    goRoute = '/api/copilot',
-  } = options
-
-  const userTimezone =
-    typeof requestPayload?.userTimezone === 'string' ? requestPayload.userTimezone : undefined
-
-  let execContext: ExecutionContext
-  if (workflowId) {
-    execContext = await prepareExecutionContext(userId, workflowId, chatId)
-  } else {
-    const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
-    execContext = {
-      userId,
-      workflowId: '',
-      workspaceId,
-      chatId,
-      decryptedEnvVars,
-    }
-  }
-  if (userTimezone) {
-    execContext.userTimezone = userTimezone
-  }
-  execContext.executionId = executionId
-  execContext.runId = runId
-  execContext.abortSignal = options.abortSignal
-  execContext.userStopSignal = options.userStopSignal
-
-  const payloadMsgId = requestPayload?.messageId
-  const messageId = typeof payloadMsgId === 'string' ? payloadMsgId : generateId()
-  execContext.messageId = messageId
-  const context = createStreamingContext({
-    chatId,
-    executionId,
-    runId,
-    messageId,
-  })
-  const continuationWorkerId = `sim-resume:${generateId()}`
-  const reqLogger = logger.withMetadata({ requestId: context.requestId, messageId })
-  let claimedToolCallIds: string[] = []
-  let claimedByWorkerId: string | null = null
-
-  reqLogger.info('Starting copilot orchestration', {
-    goRoute,
-    workflowId,
-    workspaceId,
-    chatId,
-    executionId,
-    runId,
-    hasUserTimezone: Boolean(userTimezone),
-  })
-
-  try {
-    let route = goRoute
-    let payload = requestPayload
-
-    const callerOnEvent = options.onEvent
-
-    for (;;) {
-      context.streamComplete = false
-
-      reqLogger.info('Starting orchestration loop iteration', {
-        route,
-        hasPendingAsyncContinuation: Boolean(context.awaitingAsyncContinuation),
-        claimedToolCallCount: claimedToolCallIds.length,
-      })
-
-      const loopOptions = {
-        ...options,
-        onEvent: async (event: SSEEvent) => {
-          if (event.type === 'done') {
-            const d = (event.data ?? {}) as Record<string, unknown>
-            const response = (d.response ?? {}) as Record<string, unknown>
-            if (response.async_pause) {
-              reqLogger.info('Detected async pause from copilot backend', {
-                route,
-                checkpointId:
-                  typeof (response.async_pause as Record<string, unknown>)?.checkpointId ===
-                  'string'
-                    ? (response.async_pause as Record<string, unknown>).checkpointId
-                    : undefined,
-              })
-              if (runId) {
-                await updateRunStatus(runId, 'paused_waiting_for_tool').catch(() => {})
-              }
-            }
-          }
-          await callerOnEvent?.(event)
-        },
-      }
-
-      await runStreamLoop(
-        `${SIM_AGENT_API_URL}${route}`,
-        {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
-            'X-Client-Version': SIM_AGENT_VERSION,
-          },
-          body: JSON.stringify(payload),
-        },
-        context,
-        execContext,
-        loopOptions
-      )
-
-      reqLogger.info('Completed orchestration loop iteration', {
-        route,
-        streamComplete: context.streamComplete,
-        wasAborted: context.wasAborted,
-        hasAsyncContinuation: Boolean(context.awaitingAsyncContinuation),
-        errorCount: context.errors.length,
-      })
-
-      if (claimedToolCallIds.length > 0) {
-        reqLogger.info('Marking async tool calls as delivered', {
-          toolCallIds: claimedToolCallIds,
-        })
-        await Promise.all(
-          claimedToolCallIds.map((toolCallId) =>
-            markAsyncToolDelivered(toolCallId).catch(() => null)
-          )
-        )
-        claimedToolCallIds = []
-        claimedByWorkerId = null
-      }
-
-      if (options.abortSignal?.aborted || context.wasAborted) {
-        reqLogger.info('Stopping orchestration because request was aborted', {
-          pendingToolCallCount: Array.from(context.toolCalls.values()).filter(
-            (toolCall) => toolCall.status === 'pending' || toolCall.status === 'executing'
-          ).length,
-        })
-        for (const [toolCallId, toolCall] of context.toolCalls) {
-          if (toolCall.status === 'pending' || toolCall.status === 'executing') {
-            toolCall.status = 'cancelled'
-            toolCall.endTime = Date.now()
-            toolCall.error = 'Stopped by user'
-          }
-        }
-        context.awaitingAsyncContinuation = undefined
-        break
-      }
-
-      const continuation = context.awaitingAsyncContinuation
-      if (!continuation) {
-        reqLogger.info('No async continuation pending; finishing orchestration')
-        break
-      }
-
-      let resumeReady = false
-      let resumeRetries = 0
-      reqLogger.info('Processing async continuation', {
-        checkpointId: continuation.checkpointId,
-        runId: continuation.runId,
-        pendingToolCallIds: continuation.pendingToolCallIds,
-      })
-      for (;;) {
-        claimedToolCallIds = []
-        claimedByWorkerId = null
-        const resumeWorkerId = continuationWorkerId
-        const readyTools: ReadyContinuationTool[] = []
-        const localPendingPromises: Promise<unknown>[] = []
-        const missingToolCallIds: string[] = []
-
-        for (const toolCallId of continuation.pendingToolCallIds) {
-          const durableRow = await getAsyncToolCall(toolCallId).catch(() => null)
-          const localPendingPromise = context.pendingToolPromises.get(toolCallId)
-          const toolState = context.toolCalls.get(toolCallId)
-
-          if (localPendingPromise) {
-            localPendingPromises.push(localPendingPromise)
-            reqLogger.info('Waiting for local async tool completion before retrying resume claim', {
-              toolCallId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-            })
-            continue
-          }
-
-          if (durableRow && isTerminalAsyncStatus(durableRow.status)) {
-            if (durableRow.claimedBy && durableRow.claimedBy !== resumeWorkerId) {
-              missingToolCallIds.push(toolCallId)
-              reqLogger.warn(
-                'Async tool continuation is waiting on a claim held by another worker',
-                {
-                  toolCallId,
-                  runId: continuation.runId,
-                  workerId: resumeWorkerId,
-                  claimedBy: durableRow.claimedBy,
-                }
-              )
-              continue
-            }
-            readyTools.push({
-              toolCallId,
-              toolState,
-              durableRow,
-              needsDurableClaim: durableRow.claimedBy !== resumeWorkerId,
-              alreadyClaimedByWorker: durableRow.claimedBy === resumeWorkerId,
-            })
-            continue
-          }
-
-          if (
-            !durableRow &&
-            toolState &&
-            isTerminalToolCallStatus(toolState.status) &&
-            !isToolAvailableOnSimSide(toolState.name)
-          ) {
-            reqLogger.info('Including Go-handled tool in resume payload (no Sim-side row)', {
-              toolCallId,
-              toolName: toolState.name,
-              status: toolState.status,
-              runId: continuation.runId,
-            })
-            readyTools.push({
-              toolCallId,
-              toolState,
-              needsDurableClaim: false,
-              alreadyClaimedByWorker: false,
-            })
-            continue
-          }
-
-          reqLogger.warn('Skipping already-claimed or missing async tool resume', {
-            toolCallId,
-            runId: continuation.runId,
-            durableStatus: durableRow?.status,
-            toolStateStatus: toolState?.status,
-          })
-          missingToolCallIds.push(toolCallId)
-        }
-
-        if (localPendingPromises.length > 0) {
-          reqLogger.info('Waiting for local pending async tools before resuming continuation', {
-            checkpointId: continuation.checkpointId,
-            pendingPromiseCount: localPendingPromises.length,
-          })
-          await Promise.allSettled(localPendingPromises)
-          continue
-        }
-
-        if (missingToolCallIds.length > 0) {
-          if (resumeRetries < 3) {
-            resumeRetries++
-            reqLogger.info('Retrying async resume after some tool calls were not yet ready', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              retry: resumeRetries,
-              missingToolCallIds,
-            })
-            await new Promise((resolve) => setTimeout(resolve, 250 * resumeRetries))
-            continue
-          }
-          reqLogger.error(
-            'Async continuation failed because pending tool calls never became ready',
-            {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              missingToolCallIds,
-            }
-          )
-          throw new Error(
-            `Failed to resume async tool continuation: pending tool calls were not ready (${missingToolCallIds.join(', ')})`
-          )
-        }
-
-        if (readyTools.length === 0) {
-          if (resumeRetries < 3 && continuation.pendingToolCallIds.length > 0) {
-            resumeRetries++
-            reqLogger.info('Retrying async resume because no tool calls were ready yet', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              retry: resumeRetries,
-            })
-            await new Promise((resolve) => setTimeout(resolve, 250 * resumeRetries))
-            continue
-          }
-          reqLogger.error('Async continuation failed because no tool calls were ready', {
-            checkpointId: continuation.checkpointId,
-            runId: continuation.runId,
-            requestedToolCallIds: continuation.pendingToolCallIds,
-          })
-          throw new Error('Failed to resume async tool continuation: no tool calls were ready')
-        }
-
-        const claimCandidates = readyTools.filter((tool) => tool.needsDurableClaim)
-        const newlyClaimedToolCallIds: string[] = []
-        const claimFailures: string[] = []
-
-        for (const tool of claimCandidates) {
-          const claimed = await claimCompletedAsyncToolCall(tool.toolCallId, resumeWorkerId).catch(
-            () => null
-          )
-          if (!claimed) {
-            claimFailures.push(tool.toolCallId)
-            continue
-          }
-          newlyClaimedToolCallIds.push(tool.toolCallId)
-        }
-
-        if (claimFailures.length > 0) {
-          if (newlyClaimedToolCallIds.length > 0) {
-            reqLogger.info('Releasing async tool claims after claim contention during resume', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              newlyClaimedToolCallIds,
-              claimFailures,
-            })
-            await Promise.all(
-              newlyClaimedToolCallIds.map((toolCallId) =>
-                releaseCompletedAsyncToolClaim(toolCallId, resumeWorkerId).catch(() => null)
-              )
-            )
-          }
-          if (resumeRetries < 3) {
-            resumeRetries++
-            reqLogger.info('Retrying async resume after claim contention', {
-              checkpointId: continuation.checkpointId,
-              runId: continuation.runId,
-              workerId: resumeWorkerId,
-              retry: resumeRetries,
-              claimFailures,
-            })
-            await new Promise((resolve) => setTimeout(resolve, 250 * resumeRetries))
-            continue
-          }
-          reqLogger.error('Async continuation failed because tool claims could not be acquired', {
-            checkpointId: continuation.checkpointId,
-            runId: continuation.runId,
-            claimFailures,
-          })
-          throw new Error(
-            `Failed to resume async tool continuation: unable to claim tool calls (${claimFailures.join(', ')})`
-          )
-        }
-
-        claimedToolCallIds = [
-          ...readyTools
-            .filter((tool) => tool.alreadyClaimedByWorker)
-            .map((tool) => tool.toolCallId),
-          ...newlyClaimedToolCallIds,
-        ]
-        claimedByWorkerId = claimedToolCallIds.length > 0 ? resumeWorkerId : null
-
-        reqLogger.info('Resuming async tool continuation', {
-          checkpointId: continuation.checkpointId,
-          runId: continuation.runId,
-          workerId: resumeWorkerId,
-          toolCallIds: readyTools.map((tool) => tool.toolCallId),
-        })
-
-        const durableRows = await getAsyncToolCalls(
-          readyTools.map((tool) => tool.toolCallId)
-        ).catch(() => [])
-        const durableByToolCallId = new Map(durableRows.map((row) => [row.toolCallId, row]))
-
-        const results = await Promise.all(
-          readyTools.map(async (tool) => {
-            const durable = durableByToolCallId.get(tool.toolCallId) || tool.durableRow
-            const durableStatus = durable?.status
-            const durableResult =
-              durable?.result && typeof durable.result === 'object'
-                ? (durable.result as Record<string, unknown>)
-                : undefined
-            const success = didAsyncToolSucceed({
-              durableStatus,
-              durableResult,
-              durableError: durable?.error,
-              toolStateStatus: tool.toolState?.status,
-            })
-            const data =
-              durableResult ||
-              (tool.toolState?.result?.output as Record<string, unknown> | undefined) ||
-              (success
-                ? { message: 'Tool completed' }
-                : {
-                    error: durable?.error || tool.toolState?.error || 'Tool failed',
-                  })
-
-            if (
-              durableStatus &&
-              !isTerminalAsyncStatus(durableStatus) &&
-              !isDeliveredAsyncStatus(durableStatus)
-            ) {
-              reqLogger.warn(
-                'Async tool row was claimed for resume without terminal durable state',
-                {
-                  toolCallId: tool.toolCallId,
-                  status: durableStatus,
-                }
-              )
-            }
-
-            return {
-              callId: tool.toolCallId,
-              name: durable?.toolName || tool.toolState?.name || '',
-              data,
-              success,
-            }
-          })
-        )
-
-        context.awaitingAsyncContinuation = undefined
-        route = '/api/tools/resume'
-        payload = {
-          checkpointId: continuation.checkpointId,
-          results,
-        }
-        reqLogger.info('Prepared async continuation payload for resume endpoint', {
-          route,
-          checkpointId: continuation.checkpointId,
-          resultCount: results.length,
-        })
-        resumeReady = true
-        break
-      }
-
-      if (!resumeReady) {
-        reqLogger.warn('Async continuation loop exited without resume payload', {
-          checkpointId: continuation.checkpointId,
-          runId: continuation.runId,
-        })
-        break
-      }
-    }
-
-    const result: OrchestratorResult = {
-      success: context.errors.length === 0 && !context.wasAborted,
-      content: context.accumulatedContent,
-      contentBlocks: context.contentBlocks,
-      toolCalls: buildToolCallSummaries(context),
-      chatId: context.chatId,
-      requestId: context.requestId,
-      errors: context.errors.length ? context.errors : undefined,
-      usage: context.usage,
-      cost: context.cost,
-    }
-    reqLogger.info('Completing copilot orchestration', {
-      success: result.success,
-      chatId: result.chatId,
-      hasRequestId: Boolean(result.requestId),
-      errorCount: result.errors?.length || 0,
-      toolCallCount: result.toolCalls.length,
-    })
-    await options.onComplete?.(result)
-    return result
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error('Copilot orchestration failed')
-    if (claimedToolCallIds.length > 0 && claimedByWorkerId) {
-      reqLogger.warn('Releasing async tool claims after delivery failure', {
-        toolCallIds: claimedToolCallIds,
-        workerId: claimedByWorkerId,
-      })
-      await Promise.all(
-        claimedToolCallIds.map((toolCallId) =>
-          releaseCompletedAsyncToolClaim(toolCallId, claimedByWorkerId!).catch(() => null)
-        )
-      )
-    }
-    reqLogger.error('Copilot orchestration failed', {
-      error: err.message,
-    })
-    await options.onError?.(err)
-    return {
-      success: false,
-      content: '',
-      contentBlocks: [],
-      toolCalls: [],
-      chatId: context.chatId,
-      error: err.message,
-    }
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/persistence.ts b/apps/sim/lib/copilot/orchestrator/persistence.ts
deleted file mode 100644
index d0b47ecb8fc..00000000000
--- a/apps/sim/lib/copilot/orchestrator/persistence.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { AsyncCompletionEnvelope } from '@/lib/copilot/async-runs/lifecycle'
-import { getAsyncToolCalls } from '@/lib/copilot/async-runs/repository'
-import { createPubSubChannel } from '@/lib/events/pubsub'
-
-const logger = createLogger('CopilotOrchestratorPersistence')
-
-const toolConfirmationChannel = createPubSubChannel<AsyncCompletionEnvelope>({
-  channel: 'copilot:tool-confirmation',
-  label: 'CopilotToolConfirmation',
-})
-
-/**
- * Get a tool call confirmation status from the durable async tool row.
- */
-export async function getToolConfirmation(toolCallId: string): Promise<{
-  status: string
-  message?: string
-  timestamp?: string
-  data?: Record<string, unknown>
-} | null> {
-  const [row] = await getAsyncToolCalls([toolCallId]).catch(() => [])
-  if (!row) return null
-  return {
-    status:
-      row.status === 'completed'
-        ? 'success'
-        : row.status === 'failed'
-          ? 'error'
-          : row.status === 'cancelled'
-            ? 'cancelled'
-            : row.status,
-    message: row.error || undefined,
-    data: (row.result as Record<string, unknown> | null) || undefined,
-    timestamp: row.updatedAt?.toISOString?.(),
-  }
-}
-
-export function publishToolConfirmation(event: AsyncCompletionEnvelope): void {
-  logger.info('Publishing tool confirmation event', {
-    toolCallId: event.toolCallId,
-    status: event.status,
-  })
-  toolConfirmationChannel.publish(event)
-}
-
-export async function waitForToolConfirmation(
-  toolCallId: string,
-  timeoutMs: number,
-  abortSignal?: AbortSignal,
-  options: {
-    acceptStatus?: (status: string) => boolean
-  } = {}
-): Promise<{
-  status: string
-  message?: string
-  timestamp?: string
-  data?: Record<string, unknown>
-} | null> {
-  const acceptStatus = options.acceptStatus ?? (() => true)
-  const existing = await getToolConfirmation(toolCallId)
-  if (existing && acceptStatus(existing.status)) {
-    logger.info('Resolved tool confirmation immediately', {
-      toolCallId,
-      status: existing.status,
-    })
-    return existing
-  }
-
-  return new Promise((resolve) => {
-    let settled = false
-    let timeoutId: ReturnType<typeof setTimeout> | null = null
-    let unsubscribe: (() => void) | null = null
-
-    const cleanup = () => {
-      if (timeoutId) clearTimeout(timeoutId)
-      if (unsubscribe) unsubscribe()
-      abortSignal?.removeEventListener('abort', onAbort)
-    }
-
-    const settle = (
-      value: {
-        status: string
-        message?: string
-        timestamp?: string
-        data?: Record<string, unknown>
-      } | null
-    ) => {
-      if (settled) return
-      settled = true
-      cleanup()
-      resolve(value)
-    }
-
-    const onAbort = () => settle(null)
-
-    unsubscribe = toolConfirmationChannel.subscribe((event) => {
-      if (event.toolCallId !== toolCallId) return
-      void getToolConfirmation(toolCallId).then((latest) => {
-        if (!latest || !acceptStatus(latest.status)) return
-        logger.info('Resolved tool confirmation from pubsub', {
-          toolCallId,
-          status: latest.status,
-        })
-        settle(latest)
-      })
-    })
-
-    timeoutId = setTimeout(() => settle(null), timeoutMs)
-    if (abortSignal?.aborted) {
-      settle(null)
-      return
-    }
-    abortSignal?.addEventListener('abort', onAbort, { once: true })
-
-    void getToolConfirmation(toolCallId).then((latest) => {
-      if (latest && acceptStatus(latest.status)) {
-        logger.info('Resolved tool confirmation after subscribe', {
-          toolCallId,
-          status: latest.status,
-        })
-        settle(latest)
-      }
-    })
-  })
-}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.test.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.test.ts
deleted file mode 100644
index 84099340c83..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.test.ts
+++ /dev/null
@@ -1,293 +0,0 @@
-/**
- * @vitest-environment node
- */
-
-import { loggerMock } from '@sim/testing'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-vi.mock('@sim/logger', () => loggerMock)
-
-const { executeToolServerSide, markToolComplete, isToolAvailableOnSimSide } = vi.hoisted(() => ({
-  executeToolServerSide: vi.fn(),
-  markToolComplete: vi.fn(),
-  isToolAvailableOnSimSide: vi.fn().mockReturnValue(true),
-}))
-
-const { upsertAsyncToolCall } = vi.hoisted(() => ({
-  upsertAsyncToolCall: vi.fn(),
-}))
-
-vi.mock('@/lib/copilot/orchestrator/tool-executor', () => ({
-  executeToolServerSide,
-  markToolComplete,
-  isToolAvailableOnSimSide,
-}))
-
-vi.mock('@/lib/copilot/async-runs/repository', async () => {
-  const actual = await vi.importActual<typeof import('@/lib/copilot/async-runs/repository')>(
-    '@/lib/copilot/async-runs/repository'
-  )
-  return {
-    ...actual,
-    upsertAsyncToolCall,
-  }
-})
-
-import { sseHandlers } from '@/lib/copilot/orchestrator/sse/handlers'
-import type { ExecutionContext, StreamingContext } from '@/lib/copilot/orchestrator/types'
-
-describe('sse-handlers tool lifecycle', () => {
-  let context: StreamingContext
-  let execContext: ExecutionContext
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    upsertAsyncToolCall.mockResolvedValue(null)
-    context = {
-      chatId: undefined,
-      messageId: 'msg-1',
-      accumulatedContent: '',
-      contentBlocks: [],
-      toolCalls: new Map(),
-      pendingToolPromises: new Map(),
-      currentThinkingBlock: null,
-      isInThinkingBlock: false,
-      subAgentParentToolCallId: undefined,
-      subAgentParentStack: [],
-      subAgentContent: {},
-      subAgentToolCalls: {},
-      pendingContent: '',
-      streamComplete: false,
-      wasAborted: false,
-      errors: [],
-    }
-    execContext = {
-      userId: 'user-1',
-      workflowId: 'workflow-1',
-    }
-  })
-
-  it('executes tool_call and emits tool_result + mark-complete', async () => {
-    executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
-    markToolComplete.mockResolvedValueOnce(true)
-    const onEvent = vi.fn()
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-1', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    // tool_call fires execution without awaiting (fire-and-forget for parallel execution),
-    // so we flush pending microtasks before asserting
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-    expect(onEvent).toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: 'tool_result',
-        toolCallId: 'tool-1',
-        success: true,
-      })
-    )
-
-    const updated = context.toolCalls.get('tool-1')
-    expect(updated?.status).toBe('success')
-    expect(updated?.result?.output).toEqual({ ok: true })
-  })
-
-  it('skips duplicate tool_call after result', async () => {
-    executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
-    markToolComplete.mockResolvedValueOnce(true)
-
-    const event = {
-      type: 'tool_call',
-      data: { id: 'tool-dup', name: 'read', arguments: { workflowId: 'workflow-1' } },
-    }
-
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-    await new Promise((resolve) => setTimeout(resolve, 0))
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-  })
-
-  it('marks an in-flight tool as cancelled when aborted mid-execution', async () => {
-    const abortController = new AbortController()
-    const userStopController = new AbortController()
-    execContext.abortSignal = abortController.signal
-    execContext.userStopSignal = userStopController.signal
-
-    executeToolServerSide.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          setTimeout(() => resolve({ success: true, output: { ok: true } }), 0)
-        })
-    )
-    markToolComplete.mockResolvedValue(true)
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-cancel', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      {
-        interactive: false,
-        timeout: 1000,
-        abortSignal: abortController.signal,
-        userStopSignal: userStopController.signal,
-      }
-    )
-
-    userStopController.abort()
-    abortController.abort()
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    expect(markToolComplete).toHaveBeenCalledWith(
-      'tool-cancel',
-      'read',
-      499,
-      'Request aborted during tool execution',
-      { cancelled: true },
-      'msg-1'
-    )
-
-    const updated = context.toolCalls.get('tool-cancel')
-    expect(updated?.status).toBe('cancelled')
-  })
-
-  it('does not replace an in-flight pending promise on duplicate tool_call', async () => {
-    let resolveTool: ((value: { success: boolean; output: { ok: boolean } }) => void) | undefined
-    executeToolServerSide.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          resolveTool = resolve
-        })
-    )
-    markToolComplete.mockResolvedValueOnce(true)
-
-    const event = {
-      type: 'tool_call',
-      data: { id: 'tool-inflight', name: 'read', arguments: { workflowId: 'workflow-1' } },
-    }
-
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    const firstPromise = context.pendingToolPromises.get('tool-inflight')
-    expect(firstPromise).toBeDefined()
-
-    await sseHandlers.tool_call(event as any, context, execContext, { interactive: false })
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(context.pendingToolPromises.get('tool-inflight')).toBe(firstPromise)
-
-    resolveTool?.({ success: true, output: { ok: true } })
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(context.pendingToolPromises.has('tool-inflight')).toBe(false)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-  })
-
-  it('still executes the tool when async row upsert fails', async () => {
-    upsertAsyncToolCall.mockRejectedValueOnce(new Error('db down'))
-    executeToolServerSide.mockResolvedValueOnce({ success: true, output: { ok: true } })
-    markToolComplete.mockResolvedValueOnce(true)
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-upsert-fail', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent: vi.fn(), interactive: false, timeout: 1000 }
-    )
-
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).toHaveBeenCalledTimes(1)
-    expect(markToolComplete).toHaveBeenCalledTimes(1)
-    expect(context.toolCalls.get('tool-upsert-fail')?.status).toBe('success')
-  })
-
-  it('does not execute a tool if a terminal tool_result arrives before local execution starts', async () => {
-    let resolveUpsert: ((value: null) => void) | undefined
-    upsertAsyncToolCall.mockImplementationOnce(
-      () =>
-        new Promise((resolve) => {
-          resolveUpsert = resolve
-        })
-    )
-    const onEvent = vi.fn()
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-race', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    await sseHandlers.tool_result(
-      {
-        type: 'tool_result',
-        toolCallId: 'tool-race',
-        data: { id: 'tool-race', success: true, result: { ok: true } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    resolveUpsert?.(null)
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).not.toHaveBeenCalled()
-    expect(markToolComplete).not.toHaveBeenCalled()
-    expect(context.toolCalls.get('tool-race')?.status).toBe('success')
-    expect(context.toolCalls.get('tool-race')?.result?.output).toEqual({ ok: true })
-  })
-
-  it('does not execute a tool if a tool_result arrives before the tool_call event', async () => {
-    const onEvent = vi.fn()
-
-    await sseHandlers.tool_result(
-      {
-        type: 'tool_result',
-        toolCallId: 'tool-early-result',
-        toolName: 'read',
-        data: { id: 'tool-early-result', name: 'read', success: true, result: { ok: true } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    await sseHandlers.tool_call(
-      {
-        type: 'tool_call',
-        data: { id: 'tool-early-result', name: 'read', arguments: { workflowId: 'workflow-1' } },
-      } as any,
-      context,
-      execContext,
-      { onEvent, interactive: false, timeout: 1000 }
-    )
-
-    await new Promise((resolve) => setTimeout(resolve, 0))
-
-    expect(executeToolServerSide).not.toHaveBeenCalled()
-    expect(markToolComplete).not.toHaveBeenCalled()
-    expect(context.toolCalls.get('tool-early-result')?.status).toBe('success')
-  })
-})
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.ts
deleted file mode 100644
index 7fb50f4c9b9..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/handlers.ts
+++ /dev/null
@@ -1,853 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { upsertAsyncToolCall } from '@/lib/copilot/async-runs/repository'
-import { STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
-import {
-  asRecord,
-  getEventData,
-  markToolResultSeen,
-  wasToolResultSeen,
-} from '@/lib/copilot/orchestrator/sse/utils'
-import {
-  isToolAvailableOnSimSide,
-  markToolComplete,
-} from '@/lib/copilot/orchestrator/tool-executor'
-import type {
-  ContentBlock,
-  ExecutionContext,
-  OrchestratorOptions,
-  SSEEvent,
-  StreamingContext,
-  ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { isWorkflowToolName } from '@/lib/copilot/workflow-tools'
-import { generateId } from '@/lib/core/utils/uuid'
-import { executeToolAndReport, waitForToolCompletion } from './tool-execution'
-
-const logger = createLogger('CopilotSseHandlers')
-
-/**
- * Builds an AbortSignal that fires when either the main abort signal OR
- * the client-disconnect signal fires. Used for client-executable tool waits
- * so the orchestrator doesn't block for the full timeout when the browser dies.
- */
-function buildClientToolAbortSignal(options: OrchestratorOptions): AbortSignal | undefined {
-  const { abortSignal, clientDisconnectedSignal } = options
-  if (!clientDisconnectedSignal || clientDisconnectedSignal.aborted) {
-    return clientDisconnectedSignal?.aborted ? AbortSignal.abort() : abortSignal
-  }
-  if (!abortSignal) return clientDisconnectedSignal
-
-  const combined = new AbortController()
-  const fire = () => combined.abort()
-  abortSignal.addEventListener('abort', fire, { once: true })
-  clientDisconnectedSignal.addEventListener('abort', fire, { once: true })
-  return combined.signal
-}
-
-function registerPendingToolPromise(
-  context: StreamingContext,
-  toolCallId: string,
-  pendingPromise: Promise<{ status: string; message?: string; data?: Record<string, unknown> }>
-) {
-  context.pendingToolPromises.set(toolCallId, pendingPromise)
-  pendingPromise.finally(() => {
-    if (context.pendingToolPromises.get(toolCallId) === pendingPromise) {
-      context.pendingToolPromises.delete(toolCallId)
-    }
-  })
-}
-
-/**
- * When the Sim→Go stream is aborted, avoid starting server-side tool work and
- * unblock the Go async waiter with a terminal 499 completion.
- */
-function abortPendingToolIfStreamDead(
-  toolCall: ToolCallState,
-  toolCallId: string,
-  options: OrchestratorOptions,
-  context: StreamingContext
-): boolean {
-  if (!options.abortSignal?.aborted && !context.wasAborted) {
-    return false
-  }
-  toolCall.status = 'cancelled'
-  toolCall.endTime = Date.now()
-  markToolResultSeen(toolCallId)
-  markToolComplete(
-    toolCall.id,
-    toolCall.name,
-    499,
-    'Request aborted before tool execution',
-    {
-      cancelled: true,
-    },
-    context.messageId
-  ).catch((err) => {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('markToolComplete fire-and-forget failed (stream aborted)', {
-        toolCallId: toolCall.id,
-        error: err instanceof Error ? err.message : String(err),
-      })
-  })
-  return true
-}
-
-/**
- * Extract the `ui` object from an SSE event. The server enriches
- * tool_call events with `ui: { requiresConfirmation, clientExecutable, ... }`.
- */
-function getEventUI(event: SSEEvent): {
-  requiresConfirmation: boolean
-  clientExecutable: boolean
-  internal: boolean
-  hidden: boolean
-} {
-  const raw = asRecord((event as unknown as Record<string, unknown>).ui)
-  return {
-    requiresConfirmation: raw.requiresConfirmation === true,
-    clientExecutable: raw.clientExecutable === true,
-    internal: raw.internal === true,
-    hidden: raw.hidden === true,
-  }
-}
-
-/**
- * Handle the completion signal from a client-executable tool.
- * Shared by both the main and subagent tool_call handlers.
- */
-function handleClientCompletion(
-  toolCall: ToolCallState,
-  toolCallId: string,
-  completion: { status: string; message?: string; data?: Record<string, unknown> } | null,
-  context: StreamingContext
-): void {
-  if (completion?.status === 'background') {
-    toolCall.status = 'skipped'
-    toolCall.endTime = Date.now()
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      202,
-      completion.message || 'Tool execution moved to background',
-      { background: true },
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed (client background)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-    markToolResultSeen(toolCallId)
-    return
-  }
-  if (completion?.status === 'rejected') {
-    toolCall.status = 'rejected'
-    toolCall.endTime = Date.now()
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      400,
-      completion.message || 'Tool execution rejected',
-      undefined,
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed (client rejected)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-    markToolResultSeen(toolCallId)
-    return
-  }
-  if (completion?.status === 'cancelled') {
-    toolCall.status = 'cancelled'
-    toolCall.endTime = Date.now()
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      499,
-      completion.message || 'Workflow execution was stopped manually by the user.',
-      completion.data,
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed (client cancelled)', {
-          toolCallId: toolCall.id,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-    markToolResultSeen(toolCallId)
-    return
-  }
-  const success = completion?.status === 'success'
-  toolCall.status = success ? 'success' : 'error'
-  toolCall.endTime = Date.now()
-  const msg = completion?.message || (success ? 'Tool completed' : 'Tool failed or timed out')
-  markToolComplete(
-    toolCall.id,
-    toolCall.name,
-    success ? 200 : 500,
-    msg,
-    completion?.data,
-    context.messageId
-  ).catch((err) => {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('markToolComplete fire-and-forget failed (client completion)', {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        error: err instanceof Error ? err.message : String(err),
-      })
-  })
-  markToolResultSeen(toolCallId)
-}
-
-/**
- * Emit a synthetic tool_result SSE event to the client after a client-executable
- * tool completes. The server's actual tool_result is skipped (markToolResultSeen),
- * so the client would never learn the outcome without this.
- */
-async function emitSyntheticToolResult(
-  toolCallId: string,
-  toolName: string,
-  completion: { status: string; message?: string; data?: Record<string, unknown> } | null,
-  options: OrchestratorOptions,
-  context: StreamingContext
-): Promise<void> {
-  const success = completion?.status === 'success'
-  const isCancelled = completion?.status === 'cancelled'
-
-  const resultPayload = isCancelled
-    ? { ...completion?.data, reason: 'user_cancelled', cancelledByUser: true }
-    : completion?.data
-
-  try {
-    await options.onEvent?.({
-      type: 'tool_result',
-      toolCallId,
-      toolName,
-      success,
-      result: resultPayload,
-      error: !success ? completion?.message : undefined,
-    } as SSEEvent)
-  } catch (error) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to emit synthetic tool_result', {
-        toolCallId,
-        toolName,
-        error: error instanceof Error ? error.message : String(error),
-      })
-  }
-}
-
-// Normalization + dedupe helpers live in sse-utils to keep server/client in sync.
-
-function inferToolSuccess(data: Record<string, unknown> | undefined): {
-  success: boolean
-  hasResultData: boolean
-  hasError: boolean
-} {
-  const resultObj = asRecord(data?.result)
-  const hasExplicitSuccess = data?.success !== undefined || resultObj.success !== undefined
-  const explicitSuccess = data?.success ?? resultObj.success
-  const hasResultData = data?.result !== undefined || data?.data !== undefined
-  const hasError = !!data?.error || !!resultObj.error
-  const success = hasExplicitSuccess ? !!explicitSuccess : !hasError
-  return { success, hasResultData, hasError }
-}
-
-function ensureTerminalToolCallState(
-  context: StreamingContext,
-  toolCallId: string,
-  toolName: string
-): ToolCallState {
-  const existing = context.toolCalls.get(toolCallId)
-  if (existing) {
-    return existing
-  }
-
-  const toolCall: ToolCallState = {
-    id: toolCallId,
-    name: toolName || 'unknown_tool',
-    status: 'pending',
-    startTime: Date.now(),
-  }
-  context.toolCalls.set(toolCallId, toolCall)
-  addContentBlock(context, { type: 'tool_call', toolCall })
-  return toolCall
-}
-
-export type SSEHandler = (
-  event: SSEEvent,
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options: OrchestratorOptions
-) => void | Promise<void>
-
-function addContentBlock(context: StreamingContext, block: Omit<ContentBlock, 'timestamp'>): void {
-  context.contentBlocks.push({
-    ...block,
-    timestamp: Date.now(),
-  })
-}
-
-export const sseHandlers: Record<string, SSEHandler> = {
-  chat_id: (event, context, execContext) => {
-    const chatId = asRecord(event.data).chatId as string | undefined
-    context.chatId = chatId
-    if (chatId) {
-      execContext.chatId = chatId
-    }
-  },
-  request_id: (event, context) => {
-    const rid = typeof event.data === 'string' ? event.data : undefined
-    if (rid) {
-      context.requestId = rid
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .info('Mapped copilot message to Go trace ID', {
-          goTraceId: rid,
-          chatId: context.chatId,
-          executionId: context.executionId,
-          runId: context.runId,
-        })
-    }
-  },
-  title_updated: () => {},
-  tool_result: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || (data?.id as string | undefined)
-    if (!toolCallId) return
-    const toolName =
-      event.toolName ||
-      (data?.name as string | undefined) ||
-      context.toolCalls.get(toolCallId)?.name ||
-      ''
-    const current = ensureTerminalToolCallState(context, toolCallId, toolName)
-
-    const { success, hasResultData, hasError } = inferToolSuccess(data)
-
-    current.status = success ? 'success' : 'error'
-    current.endTime = Date.now()
-    if (hasResultData) {
-      current.result = {
-        success,
-        output: data?.result || data?.data,
-      }
-    }
-    if (hasError) {
-      const resultObj = asRecord(data?.result)
-      current.error = (data?.error || resultObj.error) as string | undefined
-    }
-    markToolResultSeen(toolCallId)
-  },
-  tool_error: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || (data?.id as string | undefined)
-    if (!toolCallId) return
-    const toolName =
-      event.toolName ||
-      (data?.name as string | undefined) ||
-      context.toolCalls.get(toolCallId)?.name ||
-      ''
-    const current = ensureTerminalToolCallState(context, toolCallId, toolName)
-    current.status = 'error'
-    current.error = (data?.error as string | undefined) || 'Tool execution failed'
-    current.endTime = Date.now()
-    markToolResultSeen(toolCallId)
-  },
-  tool_call_delta: () => {
-    // Argument streaming delta — no action needed on orchestrator side
-  },
-  tool_generating: (event, context) => {
-    const data = getEventData(event)
-    const toolCallId =
-      event.toolCallId ||
-      (data?.toolCallId as string | undefined) ||
-      (data?.id as string | undefined)
-    const toolName =
-      event.toolName || (data?.toolName as string | undefined) || (data?.name as string | undefined)
-    if (!toolCallId || !toolName) return
-    if (!context.toolCalls.has(toolCallId)) {
-      const toolCall = {
-        id: toolCallId,
-        name: toolName,
-        status: 'pending' as const,
-        startTime: Date.now(),
-      }
-      context.toolCalls.set(toolCallId, toolCall)
-      addContentBlock(context, { type: 'tool_call', toolCall })
-    }
-  },
-  tool_call: async (event, context, execContext, options) => {
-    const toolData = getEventData(event) || ({} as Record<string, unknown>)
-    const toolCallId = (toolData.id as string | undefined) || event.toolCallId
-    const toolName = (toolData.name as string | undefined) || event.toolName
-    if (!toolCallId || !toolName) return
-
-    const args = (toolData.arguments || toolData.input || asRecord(event.data).input) as
-      | Record<string, unknown>
-      | undefined
-    const isPartial = toolData.partial === true
-    const existing = context.toolCalls.get(toolCallId)
-
-    if (
-      existing?.endTime ||
-      (existing && existing.status !== 'pending' && existing.status !== 'executing')
-    ) {
-      if (!existing.name && toolName) {
-        existing.name = toolName
-      }
-      if (!existing.params && args) {
-        existing.params = args
-      }
-      return
-    }
-
-    if (existing) {
-      if (args && !existing.params) existing.params = args
-      if (
-        !context.contentBlocks.some((b) => b.type === 'tool_call' && b.toolCall?.id === toolCallId)
-      ) {
-        addContentBlock(context, { type: 'tool_call', toolCall: existing })
-      }
-    } else {
-      const created = {
-        id: toolCallId,
-        name: toolName,
-        status: 'pending' as const,
-        params: args,
-        startTime: Date.now(),
-      }
-      context.toolCalls.set(toolCallId, created)
-      addContentBlock(context, { type: 'tool_call', toolCall: created })
-    }
-
-    if (isPartial) return
-    if (wasToolResultSeen(toolCallId)) return
-    if (context.pendingToolPromises.has(toolCallId) || existing?.status === 'executing') {
-      return
-    }
-
-    const toolCall = context.toolCalls.get(toolCallId)
-    if (!toolCall) return
-
-    const { clientExecutable, internal } = getEventUI(event)
-
-    if (internal) {
-      return
-    }
-
-    if (!isToolAvailableOnSimSide(toolName) && !clientExecutable) {
-      return
-    }
-
-    /**
-     * Fire tool execution without awaiting so parallel tool calls from the
-     * same LLM turn execute concurrently. executeToolAndReport is self-contained:
-     * it updates tool state, calls markToolComplete, and emits result events.
-     */
-    const fireToolExecution = () => {
-      const pendingPromise = (async () => {
-        try {
-          await upsertAsyncToolCall({
-            runId: context.runId || generateId(),
-            toolCallId,
-            toolName,
-            args,
-          })
-        } catch (err) {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async tool row before execution', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        }
-        return executeToolAndReport(toolCallId, context, execContext, options)
-      })().catch((err) => {
-        logger
-          .withMetadata({ messageId: context.messageId })
-          .error('Parallel tool execution failed', {
-            toolCallId,
-            toolName,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        return {
-          status: 'error',
-          message: err instanceof Error ? err.message : String(err),
-          data: { error: err instanceof Error ? err.message : String(err) },
-        }
-      })
-      registerPendingToolPromise(context, toolCallId, pendingPromise)
-    }
-
-    if (options.interactive === false) {
-      if (options.autoExecuteTools !== false) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      }
-      return
-    }
-
-    // Client-executable tool: execute server-side if available, otherwise
-    // delegate to the client (React UI) and wait for completion.
-    // Workflow run tools are implemented on Sim for MCP/server callers but must
-    // still run in the browser when clientExecutable so the workflow terminal
-    // receives SSE block logs (executeWorkflowWithFullLogging).
-    if (clientExecutable) {
-      const delegateWorkflowRunToClient = isWorkflowToolName(toolName)
-      if (isToolAvailableOnSimSide(toolName) && !delegateWorkflowRunToClient) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      } else {
-        toolCall.status = 'executing'
-        await upsertAsyncToolCall({
-          runId: context.runId || generateId(),
-          toolCallId,
-          toolName,
-          args,
-          status: 'running',
-        }).catch((err) => {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async tool row for client-executable tool', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        })
-        const clientWaitSignal = buildClientToolAbortSignal(options)
-        const completion = await waitForToolCompletion(
-          toolCallId,
-          options.timeout || STREAM_TIMEOUT_MS,
-          clientWaitSignal
-        )
-        handleClientCompletion(toolCall, toolCallId, completion, context)
-        await emitSyntheticToolResult(toolCallId, toolCall.name, completion, options, context)
-      }
-      return
-    }
-
-    if (options.autoExecuteTools !== false) {
-      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-        fireToolExecution()
-      }
-    }
-  },
-  reasoning: (event, context) => {
-    const d = asRecord(event.data)
-    const phase = d.phase || asRecord(d.data).phase
-    if (phase === 'start') {
-      context.isInThinkingBlock = true
-      context.currentThinkingBlock = {
-        type: 'thinking',
-        content: '',
-        timestamp: Date.now(),
-      }
-      return
-    }
-    if (phase === 'end') {
-      if (context.currentThinkingBlock) {
-        context.contentBlocks.push(context.currentThinkingBlock)
-      }
-      context.isInThinkingBlock = false
-      context.currentThinkingBlock = null
-      return
-    }
-    const chunk = (d.data || d.content || event.content) as string | undefined
-    if (!chunk || !context.currentThinkingBlock) return
-    context.currentThinkingBlock.content = `${context.currentThinkingBlock.content || ''}${chunk}`
-  },
-  content: (event, context) => {
-    // Server sends content as a plain string in event.data, not wrapped in an object.
-    let chunk: string | undefined
-    if (typeof event.data === 'string') {
-      chunk = event.data
-    } else {
-      const d = asRecord(event.data)
-      chunk = (d.content || d.data || event.content) as string | undefined
-    }
-    if (!chunk) return
-    context.accumulatedContent += chunk
-    addContentBlock(context, { type: 'text', content: chunk })
-  },
-  done: (event, context) => {
-    const d = asRecord(event.data)
-    const response = asRecord(d.response)
-    const asyncPause = asRecord(response.async_pause)
-    if (asyncPause.checkpointId) {
-      context.awaitingAsyncContinuation = {
-        checkpointId: String(asyncPause.checkpointId),
-        executionId:
-          typeof asyncPause.executionId === 'string' ? asyncPause.executionId : context.executionId,
-        runId: typeof asyncPause.runId === 'string' ? asyncPause.runId : context.runId,
-        pendingToolCallIds: Array.isArray(asyncPause.pendingToolCallIds)
-          ? asyncPause.pendingToolCallIds.map((id) => String(id))
-          : [],
-      }
-    }
-    if (d.usage) {
-      const u = asRecord(d.usage)
-      context.usage = {
-        prompt: (u.input_tokens as number) || 0,
-        completion: (u.output_tokens as number) || 0,
-      }
-    }
-    if (d.cost) {
-      const c = asRecord(d.cost)
-      context.cost = {
-        input: (c.input as number) || 0,
-        output: (c.output as number) || 0,
-        total: (c.total as number) || 0,
-      }
-    }
-    context.streamComplete = true
-  },
-  start: () => {},
-  error: (event, context) => {
-    const d = asRecord(event.data)
-    const message = (d.message || d.error || event.error) as string | undefined
-    if (message) {
-      context.errors.push(message)
-    }
-    context.streamComplete = true
-  },
-}
-
-export const subAgentHandlers: Record<string, SSEHandler> = {
-  content: (event, context) => {
-    const parentToolCallId = context.subAgentParentToolCallId
-    if (!parentToolCallId || !event.data) return
-    // Server sends content as a plain string in event.data
-    let chunk: string | undefined
-    if (typeof event.data === 'string') {
-      chunk = event.data
-    } else {
-      const d = asRecord(event.data)
-      chunk = (d.content || d.data || event.content) as string | undefined
-    }
-    if (!chunk) return
-    context.subAgentContent[parentToolCallId] =
-      (context.subAgentContent[parentToolCallId] || '') + chunk
-    addContentBlock(context, { type: 'subagent_text', content: chunk })
-  },
-  tool_call: async (event, context, execContext, options) => {
-    const parentToolCallId = context.subAgentParentToolCallId
-    if (!parentToolCallId) return
-    const toolData = getEventData(event) || ({} as Record<string, unknown>)
-    const toolCallId = (toolData.id as string | undefined) || event.toolCallId
-    const toolName = (toolData.name as string | undefined) || event.toolName
-    if (!toolCallId || !toolName) return
-    const isPartial = toolData.partial === true
-    const args = (toolData.arguments || toolData.input || asRecord(event.data).input) as
-      | Record<string, unknown>
-      | undefined
-
-    const existing = context.toolCalls.get(toolCallId)
-    // Ignore late/duplicate tool_call events once we already have a result.
-    if (wasToolResultSeen(toolCallId) || existing?.endTime) {
-      if (existing && !existing.name && toolName) {
-        existing.name = toolName
-      }
-      if (existing && !existing.params && args) {
-        existing.params = args
-      }
-      return
-    }
-
-    const toolCall: ToolCallState = {
-      id: toolCallId,
-      name: toolName,
-      status: 'pending',
-      params: args,
-      startTime: Date.now(),
-    }
-
-    // Store in both places - but do NOT overwrite existing tool call state for the same id.
-    if (!context.subAgentToolCalls[parentToolCallId]) {
-      context.subAgentToolCalls[parentToolCallId] = []
-    }
-    if (!context.subAgentToolCalls[parentToolCallId].some((tc) => tc.id === toolCallId)) {
-      context.subAgentToolCalls[parentToolCallId].push(toolCall)
-    }
-    if (!context.toolCalls.has(toolCallId)) {
-      context.toolCalls.set(toolCallId, toolCall)
-      const parentToolCall = context.toolCalls.get(parentToolCallId)
-      addContentBlock(context, {
-        type: 'tool_call',
-        toolCall,
-        calledBy: parentToolCall?.name,
-      })
-    }
-
-    if (isPartial) return
-    if (context.pendingToolPromises.has(toolCallId) || existing?.status === 'executing') {
-      return
-    }
-
-    const { clientExecutable, internal } = getEventUI(event)
-
-    if (internal) {
-      return
-    }
-
-    if (!isToolAvailableOnSimSide(toolName) && !clientExecutable) {
-      return
-    }
-
-    const fireToolExecution = () => {
-      const pendingPromise = (async () => {
-        try {
-          await upsertAsyncToolCall({
-            runId: context.runId || generateId(),
-            toolCallId,
-            toolName,
-            args,
-          })
-        } catch (err) {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async subagent tool row before execution', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        }
-        return executeToolAndReport(toolCallId, context, execContext, options)
-      })().catch((err) => {
-        logger
-          .withMetadata({ messageId: context.messageId })
-          .error('Parallel subagent tool execution failed', {
-            toolCallId,
-            toolName,
-            error: err instanceof Error ? err.message : String(err),
-          })
-        return {
-          status: 'error',
-          message: err instanceof Error ? err.message : String(err),
-          data: { error: err instanceof Error ? err.message : String(err) },
-        }
-      })
-      registerPendingToolPromise(context, toolCallId, pendingPromise)
-    }
-
-    if (options.interactive === false) {
-      if (options.autoExecuteTools !== false) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      }
-      return
-    }
-
-    if (clientExecutable) {
-      const delegateWorkflowRunToClient = isWorkflowToolName(toolName)
-      if (isToolAvailableOnSimSide(toolName) && !delegateWorkflowRunToClient) {
-        if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-          fireToolExecution()
-        }
-      } else {
-        toolCall.status = 'executing'
-        await upsertAsyncToolCall({
-          runId: context.runId || generateId(),
-          toolCallId,
-          toolName,
-          args,
-          status: 'running',
-        }).catch((err) => {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('Failed to persist async tool row for client-executable subagent tool', {
-              toolCallId,
-              toolName,
-              error: err instanceof Error ? err.message : String(err),
-            })
-        })
-        const clientWaitSignal = buildClientToolAbortSignal(options)
-        const completion = await waitForToolCompletion(
-          toolCallId,
-          options.timeout || STREAM_TIMEOUT_MS,
-          clientWaitSignal
-        )
-        handleClientCompletion(toolCall, toolCallId, completion, context)
-        await emitSyntheticToolResult(toolCallId, toolCall.name, completion, options, context)
-      }
-      return
-    }
-
-    if (options.autoExecuteTools !== false) {
-      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
-        fireToolExecution()
-      }
-    }
-  },
-  tool_result: (event, context) => {
-    const parentToolCallId = context.subAgentParentToolCallId
-    if (!parentToolCallId) return
-    const data = getEventData(event)
-    const toolCallId = event.toolCallId || (data?.id as string | undefined)
-    if (!toolCallId) return
-    const toolName = event.toolName || (data?.name as string | undefined) || ''
-
-    // Update in subAgentToolCalls.
-    const toolCalls = context.subAgentToolCalls[parentToolCallId] || []
-    const subAgentToolCall = toolCalls.find((tc) => tc.id === toolCallId)
-
-    // Also update in main toolCalls (where we added it for execution).
-    const mainToolCall = ensureTerminalToolCallState(context, toolCallId, toolName)
-
-    const { success, hasResultData, hasError } = inferToolSuccess(data)
-
-    const status = success ? 'success' : 'error'
-    const endTime = Date.now()
-    const result = hasResultData ? { success, output: data?.result || data?.data } : undefined
-
-    if (subAgentToolCall) {
-      subAgentToolCall.status = status
-      subAgentToolCall.endTime = endTime
-      if (result) subAgentToolCall.result = result
-      if (hasError) {
-        const resultObj = asRecord(data?.result)
-        subAgentToolCall.error = (data?.error || resultObj.error) as string | undefined
-      }
-    }
-
-    if (mainToolCall) {
-      mainToolCall.status = status
-      mainToolCall.endTime = endTime
-      if (result) mainToolCall.result = result
-      if (hasError) {
-        const resultObj = asRecord(data?.result)
-        mainToolCall.error = (data?.error || resultObj.error) as string | undefined
-      }
-    }
-    if (subAgentToolCall || mainToolCall) {
-      markToolResultSeen(toolCallId)
-    }
-  },
-}
-
-export function handleSubagentRouting(event: SSEEvent, context: StreamingContext): boolean {
-  if (!event.subagent) return false
-  if (!context.subAgentParentToolCallId) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Subagent event missing parent tool call', {
-        type: event.type,
-        subagent: event.subagent,
-      })
-    return false
-  }
-  return true
-}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/index.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/index.ts
deleted file mode 100644
index d0d6b14b5bf..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export type { SSEHandler } from './handlers'
-export { handleSubagentRouting, sseHandlers, subAgentHandlers } from './handlers'
diff --git a/apps/sim/lib/copilot/orchestrator/sse/handlers/tool-execution.ts b/apps/sim/lib/copilot/orchestrator/sse/handlers/tool-execution.ts
deleted file mode 100644
index e960b08a1fe..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/handlers/tool-execution.ts
+++ /dev/null
@@ -1,937 +0,0 @@
-import { db } from '@sim/db'
-import { userTableRows } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import { completeAsyncToolCall, markAsyncToolRunning } from '@/lib/copilot/async-runs/repository'
-import { waitForToolConfirmation } from '@/lib/copilot/orchestrator/persistence'
-import { asRecord, markToolResultSeen } from '@/lib/copilot/orchestrator/sse/utils'
-import { executeToolServerSide, markToolComplete } from '@/lib/copilot/orchestrator/tool-executor'
-import {
-  type ExecutionContext,
-  isTerminalToolCallStatus,
-  type OrchestratorOptions,
-  type SSEEvent,
-  type StreamingContext,
-  type ToolCallResult,
-} from '@/lib/copilot/orchestrator/types'
-import {
-  extractDeletedResourcesFromToolResult,
-  extractResourcesFromToolResult,
-  hasDeleteCapability,
-  isResourceToolName,
-  persistChatResources,
-  removeChatResources,
-} from '@/lib/copilot/resources'
-import { generateId } from '@/lib/core/utils/uuid'
-import { getTableById } from '@/lib/table/service'
-import { uploadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
-
-const logger = createLogger('CopilotSseToolExecution')
-
-const OUTPUT_PATH_TOOLS = new Set(['function_execute', 'user_table'])
-
-/**
- * Try to pull a flat array of row-objects out of the various shapes that
- * `function_execute` and `user_table` can return.
- */
-function extractTabularData(output: unknown): Record<string, unknown>[] | null {
-  if (!output || typeof output !== 'object') return null
-
-  if (Array.isArray(output)) {
-    if (output.length > 0 && typeof output[0] === 'object' && output[0] !== null) {
-      return output as Record<string, unknown>[]
-    }
-    return null
-  }
-
-  const obj = output as Record<string, unknown>
-
-  // function_execute shape: { result: [...], stdout: "..." }
-  if (Array.isArray(obj.result)) {
-    const rows = obj.result
-    if (rows.length > 0 && typeof rows[0] === 'object' && rows[0] !== null) {
-      return rows as Record<string, unknown>[]
-    }
-  }
-
-  // user_table query_rows shape: { data: { rows: [{ data: {...} }], totalCount } }
-  if (obj.data && typeof obj.data === 'object' && !Array.isArray(obj.data)) {
-    const data = obj.data as Record<string, unknown>
-    if (Array.isArray(data.rows) && data.rows.length > 0) {
-      const rows = data.rows as Record<string, unknown>[]
-      // user_table rows nest actual values inside .data
-      if (typeof rows[0].data === 'object' && rows[0].data !== null) {
-        return rows.map((r) => r.data as Record<string, unknown>)
-      }
-      return rows
-    }
-  }
-
-  return null
-}
-
-function escapeCsvValue(value: unknown): string {
-  if (value === null || value === undefined) return ''
-  const str = typeof value === 'object' ? JSON.stringify(value) : String(value)
-  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
-    return `"${str.replace(/"/g, '""')}"`
-  }
-  return str
-}
-
-function convertRowsToCsv(rows: Record<string, unknown>[]): string {
-  if (rows.length === 0) return ''
-
-  const headerSet = new Set<string>()
-  for (const row of rows) {
-    for (const key of Object.keys(row)) {
-      headerSet.add(key)
-    }
-  }
-  const headers = [...headerSet]
-
-  const lines = [headers.map(escapeCsvValue).join(',')]
-  for (const row of rows) {
-    lines.push(headers.map((h) => escapeCsvValue(row[h])).join(','))
-  }
-  return lines.join('\n')
-}
-
-type OutputFormat = 'json' | 'csv' | 'txt' | 'md' | 'html'
-
-const EXT_TO_FORMAT: Record<string, OutputFormat> = {
-  '.json': 'json',
-  '.csv': 'csv',
-  '.txt': 'txt',
-  '.md': 'md',
-  '.html': 'html',
-}
-
-const FORMAT_TO_CONTENT_TYPE: Record<OutputFormat, string> = {
-  json: 'application/json',
-  csv: 'text/csv',
-  txt: 'text/plain',
-  md: 'text/markdown',
-  html: 'text/html',
-}
-
-function normalizeOutputWorkspaceFileName(outputPath: string): string {
-  const trimmed = outputPath.trim().replace(/^\/+/, '')
-  const withoutPrefix = trimmed.startsWith('files/') ? trimmed.slice('files/'.length) : trimmed
-  if (!withoutPrefix) {
-    throw new Error('outputPath must include a file name, e.g. "files/result.json"')
-  }
-  if (withoutPrefix.includes('/')) {
-    throw new Error(
-      'outputPath must target a flat workspace file, e.g. "files/result.json". Nested paths like "files/reports/result.json" are not supported.'
-    )
-  }
-  return withoutPrefix
-}
-
-function resolveOutputFormat(fileName: string, explicit?: string): OutputFormat {
-  if (explicit && explicit in FORMAT_TO_CONTENT_TYPE) return explicit as OutputFormat
-  const ext = fileName.slice(fileName.lastIndexOf('.')).toLowerCase()
-  return EXT_TO_FORMAT[ext] ?? 'json'
-}
-
-function serializeOutputForFile(output: unknown, format: OutputFormat): string {
-  if (typeof output === 'string') return output
-
-  if (format === 'csv') {
-    const rows = extractTabularData(output)
-    if (rows && rows.length > 0) {
-      return convertRowsToCsv(rows)
-    }
-  }
-
-  return JSON.stringify(output, null, 2)
-}
-
-async function maybeWriteOutputToFile(
-  toolName: string,
-  params: Record<string, unknown> | undefined,
-  result: ToolCallResult,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  if (!result.success || !result.output) return result
-  if (!OUTPUT_PATH_TOOLS.has(toolName)) return result
-  if (!context.workspaceId || !context.userId) return result
-
-  const args = params?.args as Record<string, unknown> | undefined
-  const outputPath =
-    (params?.outputPath as string | undefined) ?? (args?.outputPath as string | undefined)
-  if (!outputPath) return result
-
-  const explicitFormat =
-    (params?.outputFormat as string | undefined) ?? (args?.outputFormat as string | undefined)
-
-  try {
-    const fileName = normalizeOutputWorkspaceFileName(outputPath)
-    const format = resolveOutputFormat(fileName, explicitFormat)
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    const content = serializeOutputForFile(result.output, format)
-    const contentType = FORMAT_TO_CONTENT_TYPE[format]
-
-    const buffer = Buffer.from(content, 'utf-8')
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    const uploaded = await uploadWorkspaceFile(
-      context.workspaceId,
-      context.userId,
-      buffer,
-      fileName,
-      contentType
-    )
-
-    logger.withMetadata({ messageId: context.messageId }).info('Tool output written to file', {
-      toolName,
-      fileName,
-      size: buffer.length,
-      fileId: uploaded.id,
-    })
-
-    return {
-      success: true,
-      output: {
-        message: `Output written to files/${fileName} (${buffer.length} bytes)`,
-        fileId: uploaded.id,
-        fileName,
-        size: buffer.length,
-        downloadUrl: uploaded.url,
-      },
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err)
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to write tool output to file', {
-        toolName,
-        outputPath,
-        error: message,
-      })
-    return {
-      success: false,
-      error: `Failed to write output file: ${message}`,
-    }
-  }
-}
-
-const MAX_OUTPUT_TABLE_ROWS = 10_000
-const BATCH_CHUNK_SIZE = 500
-
-export interface AsyncToolCompletion {
-  status: string
-  message?: string
-  data?: Record<string, unknown>
-}
-
-function abortRequested(
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options?: OrchestratorOptions
-): boolean {
-  if (options?.userStopSignal?.aborted || execContext.userStopSignal?.aborted) {
-    return true
-  }
-  if (context.wasAborted) {
-    return true
-  }
-  return false
-}
-
-function cancelledCompletion(message: string): AsyncToolCompletion {
-  return {
-    status: 'cancelled',
-    message,
-    data: { cancelled: true },
-  }
-}
-
-function terminalCompletionFromToolCall(toolCall: {
-  status: string
-  error?: string
-  result?: { output?: unknown; error?: string }
-}): AsyncToolCompletion {
-  if (toolCall.status === 'cancelled') {
-    return cancelledCompletion(toolCall.error || 'Tool execution cancelled')
-  }
-
-  if (toolCall.status === 'success') {
-    return {
-      status: 'success',
-      message: 'Tool completed',
-      data:
-        toolCall.result?.output &&
-        typeof toolCall.result.output === 'object' &&
-        !Array.isArray(toolCall.result.output)
-          ? (toolCall.result.output as Record<string, unknown>)
-          : undefined,
-    }
-  }
-
-  if (toolCall.status === 'skipped') {
-    return {
-      status: 'success',
-      message: 'Tool skipped',
-      data:
-        toolCall.result?.output &&
-        typeof toolCall.result.output === 'object' &&
-        !Array.isArray(toolCall.result.output)
-          ? (toolCall.result.output as Record<string, unknown>)
-          : undefined,
-    }
-  }
-
-  return {
-    status: toolCall.status === 'rejected' ? 'rejected' : 'error',
-    message: toolCall.error || toolCall.result?.error || 'Tool failed',
-    data: { error: toolCall.error || toolCall.result?.error || 'Tool failed' },
-  }
-}
-
-function reportCancelledTool(
-  toolCall: { id: string; name: string },
-  message: string,
-  messageId?: string,
-  data: Record<string, unknown> = { cancelled: true }
-): void {
-  markToolComplete(toolCall.id, toolCall.name, 499, message, data, messageId).catch((err) => {
-    logger.withMetadata({ messageId }).error('markToolComplete failed (cancelled)', {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      error: err instanceof Error ? err.message : String(err),
-    })
-  })
-}
-
-async function maybeWriteOutputToTable(
-  toolName: string,
-  params: Record<string, unknown> | undefined,
-  result: ToolCallResult,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  if (toolName !== 'function_execute') return result
-  if (!result.success || !result.output) return result
-  if (!context.workspaceId || !context.userId) return result
-
-  const outputTable = params?.outputTable as string | undefined
-  if (!outputTable) return result
-
-  try {
-    const table = await getTableById(outputTable)
-    if (!table) {
-      return {
-        success: false,
-        error: `Table "${outputTable}" not found`,
-      }
-    }
-
-    const rawOutput = result.output
-    let rows: Array<Record<string, unknown>>
-
-    if (rawOutput && typeof rawOutput === 'object' && 'result' in rawOutput) {
-      const inner = (rawOutput as Record<string, unknown>).result
-      if (Array.isArray(inner)) {
-        rows = inner
-      } else {
-        return {
-          success: false,
-          error: 'outputTable requires the code to return an array of objects',
-        }
-      }
-    } else if (Array.isArray(rawOutput)) {
-      rows = rawOutput
-    } else {
-      return {
-        success: false,
-        error: 'outputTable requires the code to return an array of objects',
-      }
-    }
-
-    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
-      return {
-        success: false,
-        error: `outputTable row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
-      }
-    }
-
-    if (rows.length === 0) {
-      return {
-        success: false,
-        error: 'outputTable requires at least one row — code returned an empty array',
-      }
-    }
-
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    await db.transaction(async (tx) => {
-      if (context.abortSignal?.aborted) {
-        throw new Error('Request aborted before tool mutation could be applied')
-      }
-      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
-
-      const now = new Date()
-      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
-        if (context.abortSignal?.aborted) {
-          throw new Error('Request aborted before tool mutation could be applied')
-        }
-        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
-        const values = chunk.map((rowData, j) => ({
-          id: `row_${generateId().replace(/-/g, '')}`,
-          tableId: outputTable,
-          workspaceId: context.workspaceId!,
-          data: rowData,
-          position: i + j,
-          createdAt: now,
-          updatedAt: now,
-          createdBy: context.userId,
-        }))
-        await tx.insert(userTableRows).values(values)
-      }
-    })
-
-    logger.withMetadata({ messageId: context.messageId }).info('Tool output written to table', {
-      toolName,
-      tableId: outputTable,
-      rowCount: rows.length,
-    })
-
-    return {
-      success: true,
-      output: {
-        message: `Wrote ${rows.length} rows to table ${outputTable}`,
-        tableId: outputTable,
-        rowCount: rows.length,
-      },
-    }
-  } catch (err) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to write tool output to table', {
-        toolName,
-        outputTable,
-        error: err instanceof Error ? err.message : String(err),
-      })
-    return {
-      success: false,
-      error: `Failed to write to table: ${err instanceof Error ? err.message : String(err)}`,
-    }
-  }
-}
-
-async function maybeWriteReadCsvToTable(
-  toolName: string,
-  params: Record<string, unknown> | undefined,
-  result: ToolCallResult,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  if (toolName !== 'read') return result
-  if (!result.success || !result.output) return result
-  if (!context.workspaceId || !context.userId) return result
-
-  const outputTable = params?.outputTable as string | undefined
-  if (!outputTable) return result
-
-  try {
-    const table = await getTableById(outputTable)
-    if (!table) {
-      return { success: false, error: `Table "${outputTable}" not found` }
-    }
-
-    const output = result.output as Record<string, unknown>
-    const content = (output.content as string) || ''
-    if (!content.trim()) {
-      return { success: false, error: 'File has no content to import into table' }
-    }
-
-    const filePath = (params?.path as string) || ''
-    const ext = filePath.split('.').pop()?.toLowerCase()
-
-    let rows: Record<string, unknown>[]
-
-    if (ext === 'json') {
-      const parsed = JSON.parse(content)
-      if (!Array.isArray(parsed)) {
-        return {
-          success: false,
-          error: 'JSON file must contain an array of objects for table import',
-        }
-      }
-      rows = parsed
-    } else {
-      const { parse } = await import('csv-parse/sync')
-      rows = parse(content, {
-        columns: true,
-        skip_empty_lines: true,
-        trim: true,
-        relax_column_count: true,
-        relax_quotes: true,
-        skip_records_with_error: true,
-        cast: false,
-      }) as Record<string, unknown>[]
-    }
-
-    if (rows.length === 0) {
-      return { success: false, error: 'File has no data rows to import' }
-    }
-
-    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
-      return {
-        success: false,
-        error: `Row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
-      }
-    }
-
-    if (context.abortSignal?.aborted) {
-      throw new Error('Request aborted before tool mutation could be applied')
-    }
-    await db.transaction(async (tx) => {
-      if (context.abortSignal?.aborted) {
-        throw new Error('Request aborted before tool mutation could be applied')
-      }
-      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
-
-      const now = new Date()
-      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
-        if (context.abortSignal?.aborted) {
-          throw new Error('Request aborted before tool mutation could be applied')
-        }
-        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
-        const values = chunk.map((rowData, j) => ({
-          id: `row_${generateId().replace(/-/g, '')}`,
-          tableId: outputTable,
-          workspaceId: context.workspaceId!,
-          data: rowData,
-          position: i + j,
-          createdAt: now,
-          updatedAt: now,
-          createdBy: context.userId,
-        }))
-        await tx.insert(userTableRows).values(values)
-      }
-    })
-
-    logger.withMetadata({ messageId: context.messageId }).info('Read output written to table', {
-      toolName,
-      tableId: outputTable,
-      tableName: table.name,
-      rowCount: rows.length,
-      filePath,
-    })
-
-    return {
-      success: true,
-      output: {
-        message: `Imported ${rows.length} rows from "${filePath}" into table "${table.name}"`,
-        tableId: outputTable,
-        tableName: table.name,
-        rowCount: rows.length,
-      },
-    }
-  } catch (err) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Failed to write read output to table', {
-        toolName,
-        outputTable,
-        error: err instanceof Error ? err.message : String(err),
-      })
-    return {
-      success: false,
-      error: `Failed to import into table: ${err instanceof Error ? err.message : String(err)}`,
-    }
-  }
-}
-
-export async function executeToolAndReport(
-  toolCallId: string,
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options?: OrchestratorOptions
-): Promise<AsyncToolCompletion> {
-  const toolCall = context.toolCalls.get(toolCallId)
-  if (!toolCall) return { status: 'error', message: 'Tool call not found' }
-
-  if (toolCall.status === 'executing') {
-    return { status: 'running', message: 'Tool already executing' }
-  }
-  if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
-    return terminalCompletionFromToolCall(toolCall)
-  }
-
-  if (abortRequested(context, execContext, options)) {
-    toolCall.status = 'cancelled'
-    toolCall.endTime = Date.now()
-    markToolResultSeen(toolCall.id)
-    await completeAsyncToolCall({
-      toolCallId: toolCall.id,
-      status: 'cancelled',
-      result: { cancelled: true },
-      error: 'Request aborted before tool execution',
-    }).catch(() => {})
-    reportCancelledTool(toolCall, 'Request aborted before tool execution', context.messageId)
-    return cancelledCompletion('Request aborted before tool execution')
-  }
-
-  toolCall.status = 'executing'
-  await markAsyncToolRunning(toolCall.id, 'sim-stream').catch(() => {})
-
-  logger.withMetadata({ messageId: context.messageId }).info('Tool execution started', {
-    toolCallId: toolCall.id,
-    toolName: toolCall.name,
-    params: toolCall.params,
-  })
-
-  try {
-    let result = await executeToolServerSide(toolCall, execContext)
-    if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
-      return terminalCompletionFromToolCall(toolCall)
-    }
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool execution',
-      }).catch(() => {})
-      reportCancelledTool(toolCall, 'Request aborted during tool execution', context.messageId)
-      return cancelledCompletion('Request aborted during tool execution')
-    }
-    result = await maybeWriteOutputToFile(toolCall.name, toolCall.params, result, execContext)
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool post-processing',
-      }).catch(() => {})
-      reportCancelledTool(
-        toolCall,
-        'Request aborted during tool post-processing',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted during tool post-processing')
-    }
-    result = await maybeWriteOutputToTable(toolCall.name, toolCall.params, result, execContext)
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool post-processing',
-      }).catch(() => {})
-      reportCancelledTool(
-        toolCall,
-        'Request aborted during tool post-processing',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted during tool post-processing')
-    }
-    result = await maybeWriteReadCsvToTable(toolCall.name, toolCall.params, result, execContext)
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool post-processing',
-      }).catch(() => {})
-      reportCancelledTool(
-        toolCall,
-        'Request aborted during tool post-processing',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted during tool post-processing')
-    }
-    toolCall.status = result.success ? 'success' : 'error'
-    toolCall.result = result
-    toolCall.error = result.error
-    toolCall.endTime = Date.now()
-
-    if (result.success) {
-      const raw = result.output
-      const preview =
-        typeof raw === 'string'
-          ? raw.slice(0, 200)
-          : raw && typeof raw === 'object'
-            ? JSON.stringify(raw).slice(0, 200)
-            : undefined
-      logger.withMetadata({ messageId: context.messageId }).info('Tool execution succeeded', {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        outputPreview: preview,
-      })
-    } else {
-      logger.withMetadata({ messageId: context.messageId }).warn('Tool execution failed', {
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        error: result.error,
-        params: toolCall.params,
-      })
-    }
-
-    // If create_workflow was successful, update the execution context with the new workflowId.
-    // This ensures subsequent tools in the same stream have access to the workflowId.
-    const output = asRecord(result.output)
-    if (
-      toolCall.name === 'create_workflow' &&
-      result.success &&
-      output.workflowId &&
-      !execContext.workflowId
-    ) {
-      execContext.workflowId = output.workflowId as string
-      if (output.workspaceId) {
-        execContext.workspaceId = output.workspaceId as string
-      }
-    }
-
-    markToolResultSeen(toolCall.id)
-    await completeAsyncToolCall({
-      toolCallId: toolCall.id,
-      status: result.success ? 'completed' : 'failed',
-      result: result.success ? asRecord(result.output) : { error: result.error || 'Tool failed' },
-      error: result.success ? null : result.error || 'Tool failed',
-    }).catch(() => {})
-
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      reportCancelledTool(
-        toolCall,
-        'Request aborted before tool result delivery',
-        context.messageId
-      )
-      return cancelledCompletion('Request aborted before tool result delivery')
-    }
-
-    // Fire-and-forget: notify the copilot backend that the tool completed.
-    // IMPORTANT: We must NOT await this — the server may block on the
-    // mark-complete handler until it can write back on the SSE stream, but
-    // the SSE reader (our for-await loop) is paused while we're in this
-    // handler.  Awaiting here would deadlock: sim waits for the server's response,
-    // the server waits for sim to drain the SSE stream.
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      result.success ? 200 : 500,
-      result.error || (result.success ? 'Tool completed' : 'Tool failed'),
-      result.output,
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed', {
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-
-    const resultEvent: SSEEvent = {
-      type: 'tool_result',
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      success: result.success,
-      result: result.output,
-      data: {
-        id: toolCall.id,
-        name: toolCall.name,
-        success: result.success,
-        result: result.output,
-      },
-    }
-    await options?.onEvent?.(resultEvent)
-
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      return cancelledCompletion('Request aborted before resource persistence')
-    }
-
-    if (result.success && execContext.chatId && !abortRequested(context, execContext, options)) {
-      let isDeleteOp = false
-
-      if (hasDeleteCapability(toolCall.name)) {
-        const deleted = extractDeletedResourcesFromToolResult(
-          toolCall.name,
-          toolCall.params,
-          result.output
-        )
-        if (deleted.length > 0) {
-          isDeleteOp = true
-          removeChatResources(execContext.chatId, deleted).catch((err) => {
-            logger
-              .withMetadata({ messageId: context.messageId })
-              .warn('Failed to remove chat resources after deletion', {
-                chatId: execContext.chatId,
-                error: err instanceof Error ? err.message : String(err),
-              })
-          })
-
-          for (const resource of deleted) {
-            if (abortRequested(context, execContext, options)) break
-            await options?.onEvent?.({
-              type: 'resource_deleted',
-              resource: { type: resource.type, id: resource.id, title: resource.title },
-            })
-          }
-        }
-      }
-
-      if (!isDeleteOp && !abortRequested(context, execContext, options)) {
-        const resources =
-          result.resources && result.resources.length > 0
-            ? result.resources
-            : isResourceToolName(toolCall.name)
-              ? extractResourcesFromToolResult(toolCall.name, toolCall.params, result.output)
-              : []
-
-        if (resources.length > 0) {
-          persistChatResources(execContext.chatId, resources).catch((err) => {
-            logger
-              .withMetadata({ messageId: context.messageId })
-              .warn('Failed to persist chat resources', {
-                chatId: execContext.chatId,
-                error: err instanceof Error ? err.message : String(err),
-              })
-          })
-
-          for (const resource of resources) {
-            if (abortRequested(context, execContext, options)) break
-            await options?.onEvent?.({
-              type: 'resource_added',
-              resource: { type: resource.type, id: resource.id, title: resource.title },
-            })
-          }
-        }
-      }
-    }
-    return {
-      status: result.success ? 'success' : 'error',
-      message: result.error || (result.success ? 'Tool completed' : 'Tool failed'),
-      data: asRecord(result.output),
-    }
-  } catch (error) {
-    if (abortRequested(context, execContext, options)) {
-      toolCall.status = 'cancelled'
-      toolCall.endTime = Date.now()
-      markToolResultSeen(toolCall.id)
-      await completeAsyncToolCall({
-        toolCallId: toolCall.id,
-        status: 'cancelled',
-        result: { cancelled: true },
-        error: 'Request aborted during tool execution',
-      }).catch(() => {})
-      reportCancelledTool(toolCall, 'Request aborted during tool execution', context.messageId)
-      return cancelledCompletion('Request aborted during tool execution')
-    }
-    toolCall.status = 'error'
-    toolCall.error = error instanceof Error ? error.message : String(error)
-    toolCall.endTime = Date.now()
-
-    logger.withMetadata({ messageId: context.messageId }).error('Tool execution threw', {
-      toolCallId: toolCall.id,
-      toolName: toolCall.name,
-      error: toolCall.error,
-      params: toolCall.params,
-    })
-
-    markToolResultSeen(toolCall.id)
-    await completeAsyncToolCall({
-      toolCallId: toolCall.id,
-      status: 'failed',
-      result: { error: toolCall.error },
-      error: toolCall.error,
-    }).catch(() => {})
-
-    // Fire-and-forget (same reasoning as above).
-    // Pass error as structured data so the Go side can surface it to the LLM.
-    markToolComplete(
-      toolCall.id,
-      toolCall.name,
-      500,
-      toolCall.error,
-      {
-        error: toolCall.error,
-      },
-      context.messageId
-    ).catch((err) => {
-      logger
-        .withMetadata({ messageId: context.messageId })
-        .error('markToolComplete fire-and-forget failed', {
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          error: err instanceof Error ? err.message : String(err),
-        })
-    })
-
-    const errorEvent: SSEEvent = {
-      type: 'tool_error',
-      state: 'error',
-      toolCallId: toolCall.id,
-      data: {
-        id: toolCall.id,
-        name: toolCall.name,
-        error: toolCall.error,
-      },
-    }
-    await options?.onEvent?.(errorEvent)
-    return {
-      status: 'error',
-      message: toolCall.error,
-      data: { error: toolCall.error },
-    }
-  }
-}
-
-/**
- * Wait for a tool completion signal (success/error/rejected) from the client.
- * Ignores intermediate statuses like `accepted` and only returns terminal statuses:
- * - success: client finished executing successfully
- * - error: client execution failed
- * - rejected: user clicked Skip (subagent run tools where user hasn't auto-allowed)
- *
- * Used for client-executable run tools: the client executes the workflow
- * and posts success/error to /api/copilot/confirm when done. The server
- * waits here until that completion signal arrives.
- */
-export async function waitForToolCompletion(
-  toolCallId: string,
-  timeoutMs: number,
-  abortSignal?: AbortSignal
-): Promise<{ status: string; message?: string; data?: Record<string, unknown> } | null> {
-  const decision = await waitForToolConfirmation(toolCallId, timeoutMs, abortSignal, {
-    acceptStatus: (status) =>
-      status === 'success' ||
-      status === 'error' ||
-      status === 'rejected' ||
-      status === 'background' ||
-      status === 'cancelled' ||
-      status === 'delivered',
-  })
-  if (
-    decision?.status === 'success' ||
-    decision?.status === 'error' ||
-    decision?.status === 'rejected' ||
-    decision?.status === 'background' ||
-    decision?.status === 'cancelled' ||
-    decision?.status === 'delivered'
-  ) {
-    return decision
-  }
-  return null
-}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/parser.ts b/apps/sim/lib/copilot/orchestrator/sse/parser.ts
deleted file mode 100644
index d2fd0355c85..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/parser.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { SSEEvent } from '@/lib/copilot/orchestrator/types'
-
-const logger = createLogger('CopilotSseParser')
-
-/**
- * Parses SSE streams from the copilot backend into typed events.
- */
-export async function* parseSSEStream(
-  reader: ReadableStreamDefaultReader<Uint8Array>,
-  decoder: TextDecoder,
-  abortSignal?: AbortSignal
-): AsyncGenerator<SSEEvent> {
-  let buffer = ''
-
-  try {
-    try {
-      while (true) {
-        if (abortSignal?.aborted) {
-          logger.info('SSE stream aborted by signal')
-          break
-        }
-
-        const { done, value } = await reader.read()
-        if (done) break
-
-        buffer += decoder.decode(value, { stream: true })
-        const lines = buffer.split('\n')
-        buffer = lines.pop() || ''
-
-        for (const line of lines) {
-          if (abortSignal?.aborted) {
-            logger.info('SSE stream aborted mid-chunk (between events)')
-            return
-          }
-          if (!line.trim()) continue
-          if (!line.startsWith('data: ')) continue
-
-          const jsonStr = line.slice(6)
-          if (jsonStr === '[DONE]') continue
-
-          try {
-            const event = JSON.parse(jsonStr) as SSEEvent
-            if (event?.type) {
-              yield event
-            }
-          } catch (error) {
-            logger.warn('Failed to parse SSE event', {
-              preview: jsonStr.slice(0, 200),
-              error: error instanceof Error ? error.message : String(error),
-            })
-          }
-        }
-      }
-    } catch (error) {
-      const aborted =
-        abortSignal?.aborted || (error instanceof DOMException && error.name === 'AbortError')
-      if (aborted) {
-        logger.info('SSE stream read aborted')
-        return
-      }
-      throw error
-    }
-
-    if (buffer.trim() && buffer.startsWith('data: ')) {
-      try {
-        const event = JSON.parse(buffer.slice(6)) as SSEEvent
-        if (event?.type) {
-          yield event
-        }
-      } catch (error) {
-        logger.warn('Failed to parse final SSE buffer', {
-          preview: buffer.slice(0, 200),
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-    }
-  } finally {
-    try {
-      reader.releaseLock()
-    } catch {
-      logger.warn('Failed to release SSE reader lock')
-    }
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/sse/utils.test.ts b/apps/sim/lib/copilot/orchestrator/sse/utils.test.ts
deleted file mode 100644
index 56eaad33789..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/utils.test.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { describe, expect, it } from 'vitest'
-import {
-  markToolResultSeen,
-  normalizeSseEvent,
-  shouldSkipToolCallEvent,
-  shouldSkipToolResultEvent,
-} from '@/lib/copilot/orchestrator/sse/utils'
-
-describe('sse-utils', () => {
-  it.concurrent('normalizes tool fields from string data', () => {
-    const event = {
-      type: 'tool_result',
-      data: JSON.stringify({
-        id: 'tool_1',
-        name: 'edit_workflow',
-        success: true,
-        result: { ok: true },
-      }),
-    }
-
-    const normalized = normalizeSseEvent(event as any)
-
-    expect(normalized.toolCallId).toBe('tool_1')
-    expect(normalized.toolName).toBe('edit_workflow')
-    expect(normalized.success).toBe(true)
-    expect(normalized.result).toEqual({ ok: true })
-  })
-
-  it.concurrent('dedupes tool_call events', () => {
-    const event = { type: 'tool_call', data: { id: 'tool_call_1', name: 'plan' } }
-    expect(shouldSkipToolCallEvent(event as any)).toBe(false)
-    expect(shouldSkipToolCallEvent(event as any)).toBe(true)
-  })
-
-  it.concurrent('dedupes tool_result events', () => {
-    const event = { type: 'tool_result', data: { id: 'tool_result_1', name: 'plan' } }
-    expect(shouldSkipToolResultEvent(event as any)).toBe(false)
-    markToolResultSeen('tool_result_1')
-    expect(shouldSkipToolResultEvent(event as any)).toBe(true)
-  })
-})
diff --git a/apps/sim/lib/copilot/orchestrator/sse/utils.ts b/apps/sim/lib/copilot/orchestrator/sse/utils.ts
deleted file mode 100644
index 3619012d9f9..00000000000
--- a/apps/sim/lib/copilot/orchestrator/sse/utils.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-import { STREAM_BUFFER_MAX_DEDUP_ENTRIES } from '@/lib/copilot/constants'
-import type { SSEEvent } from '@/lib/copilot/orchestrator/types'
-
-type EventDataObject = Record<string, unknown> | undefined
-
-/** Safely cast event.data to a record for property access. */
-export const asRecord = (data: unknown): Record<string, unknown> =>
-  (data && typeof data === 'object' && !Array.isArray(data) ? data : {}) as Record<string, unknown>
-
-/**
- * In-memory tool event dedupe with bounded size.
- *
- * NOTE: Process-local only. In a multi-instance setup (e.g., ECS),
- * each task maintains its own dedupe cache.
- */
-const seenToolCalls = new Set<string>()
-const seenToolResults = new Set<string>()
-
-function addToSet(set: Set<string>, id: string): void {
-  if (set.size >= STREAM_BUFFER_MAX_DEDUP_ENTRIES) {
-    const first = set.values().next().value
-    if (first) set.delete(first)
-  }
-  set.add(id)
-}
-
-const parseEventData = (data: unknown): EventDataObject => {
-  if (!data) return undefined
-  if (typeof data !== 'string') {
-    if (typeof data === 'object' && !Array.isArray(data)) {
-      return data as EventDataObject
-    }
-    return undefined
-  }
-  try {
-    const parsed = JSON.parse(data)
-    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
-      return parsed as EventDataObject
-    }
-    return undefined
-  } catch {
-    return undefined
-  }
-}
-
-const hasToolFields = (data: EventDataObject): boolean => {
-  if (!data) return false
-  return (
-    data.id !== undefined ||
-    data.toolCallId !== undefined ||
-    data.name !== undefined ||
-    data.success !== undefined ||
-    data.result !== undefined ||
-    data.arguments !== undefined
-  )
-}
-
-export const getEventData = (event: SSEEvent): EventDataObject => {
-  const topLevel = parseEventData(event.data)
-  if (!topLevel) return undefined
-  if (hasToolFields(topLevel)) return topLevel
-  const nested = parseEventData(topLevel.data)
-  return nested || topLevel
-}
-
-function getToolCallIdFromEvent(event: SSEEvent): string | undefined {
-  const data = getEventData(event)
-  return (
-    event.toolCallId || (data?.id as string | undefined) || (data?.toolCallId as string | undefined)
-  )
-}
-
-/** Normalizes SSE events so tool metadata is available at the top level. */
-export function normalizeSseEvent(event: SSEEvent): SSEEvent {
-  if (!event) return event
-  const data = getEventData(event)
-  if (!data) return event
-  const toolCallId =
-    event.toolCallId || (data.id as string | undefined) || (data.toolCallId as string | undefined)
-  const toolName =
-    event.toolName || (data.name as string | undefined) || (data.toolName as string | undefined)
-  const success = event.success ?? (data.success as boolean | undefined)
-  const result = event.result ?? data.result
-  const normalizedData = typeof event.data === 'string' ? data : event.data
-  return {
-    ...event,
-    data: normalizedData,
-    toolCallId,
-    toolName,
-    success,
-    result,
-  }
-}
-
-function markToolCallSeen(toolCallId: string): void {
-  addToSet(seenToolCalls, toolCallId)
-}
-
-function wasToolCallSeen(toolCallId: string): boolean {
-  return seenToolCalls.has(toolCallId)
-}
-
-export function markToolResultSeen(toolCallId: string): void {
-  addToSet(seenToolResults, toolCallId)
-}
-
-export function wasToolResultSeen(toolCallId: string): boolean {
-  return seenToolResults.has(toolCallId)
-}
-
-export function shouldSkipToolCallEvent(event: SSEEvent): boolean {
-  if (event.type !== 'tool_call') return false
-  const toolCallId = getToolCallIdFromEvent(event)
-  if (!toolCallId) return false
-  const eventData = getEventData(event)
-  if (eventData?.partial === true) return false
-  if (wasToolResultSeen(toolCallId) || wasToolCallSeen(toolCallId)) {
-    return true
-  }
-  markToolCallSeen(toolCallId)
-  return false
-}
-
-export function shouldSkipToolResultEvent(event: SSEEvent): boolean {
-  if (event.type !== 'tool_result') return false
-  const toolCallId = getToolCallIdFromEvent(event)
-  if (!toolCallId) return false
-  return wasToolResultSeen(toolCallId)
-}
diff --git a/apps/sim/lib/copilot/orchestrator/stream/buffer.test.ts b/apps/sim/lib/copilot/orchestrator/stream/buffer.test.ts
deleted file mode 100644
index 1a87edbb366..00000000000
--- a/apps/sim/lib/copilot/orchestrator/stream/buffer.test.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- * @vitest-environment node
- */
-
-import { loggerMock } from '@sim/testing'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-vi.mock('@sim/logger', () => loggerMock)
-
-type StoredEntry = { score: number; value: string }
-
-const createRedisStub = () => {
-  const events = new Map<string, StoredEntry[]>()
-  const counters = new Map<string, number>()
-
-  const readEntries = (key: string, min: number, max: number) => {
-    const list = events.get(key) || []
-    return list
-      .filter((entry) => entry.score >= min && entry.score <= max)
-      .sort((a, b) => a.score - b.score)
-      .map((entry) => entry.value)
-  }
-
-  return {
-    del: vi.fn().mockResolvedValue(1),
-    hset: vi.fn().mockResolvedValue(1),
-    hgetall: vi.fn().mockResolvedValue({}),
-    expire: vi.fn().mockResolvedValue(1),
-    eval: vi
-      .fn()
-      .mockImplementation(
-        (
-          _lua: string,
-          _keysCount: number,
-          seqKey: string,
-          eventsKey: string,
-          _ttl: number,
-          _limit: number,
-          streamId: string,
-          eventJson: string
-        ) => {
-          const current = counters.get(seqKey) || 0
-          const next = current + 1
-          counters.set(seqKey, next)
-          const entry = JSON.stringify({ eventId: next, streamId, event: JSON.parse(eventJson) })
-          const list = events.get(eventsKey) || []
-          list.push({ score: next, value: entry })
-          events.set(eventsKey, list)
-          return next
-        }
-      ),
-    incrby: vi.fn().mockImplementation((key: string, amount: number) => {
-      const current = counters.get(key) || 0
-      const next = current + amount
-      counters.set(key, next)
-      return next
-    }),
-    zrangebyscore: vi.fn().mockImplementation((key: string, min: string, max: string) => {
-      const minVal = Number(min)
-      const maxVal = max === '+inf' ? Number.POSITIVE_INFINITY : Number(max)
-      return Promise.resolve(readEntries(key, minVal, maxVal))
-    }),
-    pipeline: vi.fn().mockImplementation(() => {
-      const api: Record<string, any> = {}
-      api.zadd = vi.fn().mockImplementation((key: string, ...args: Array<string | number>) => {
-        const list = events.get(key) || []
-        for (let i = 0; i < args.length; i += 2) {
-          list.push({ score: Number(args[i]), value: String(args[i + 1]) })
-        }
-        events.set(key, list)
-        return api
-      })
-      api.expire = vi.fn().mockReturnValue(api)
-      api.zremrangebyrank = vi.fn().mockReturnValue(api)
-      api.exec = vi.fn().mockResolvedValue([])
-      return api
-    }),
-  }
-}
-
-let mockRedis: ReturnType<typeof createRedisStub>
-
-vi.mock('@/lib/core/config/redis', () => ({
-  getRedisClient: () => mockRedis,
-}))
-
-import {
-  appendStreamEvent,
-  createStreamEventWriter,
-  readStreamEvents,
-} from '@/lib/copilot/orchestrator/stream/buffer'
-
-describe('stream-buffer', () => {
-  beforeEach(() => {
-    mockRedis = createRedisStub()
-    vi.clearAllMocks()
-  })
-
-  it.concurrent('replays events after a given event id', async () => {
-    await appendStreamEvent('stream-1', { type: 'content', data: 'hello' })
-    await appendStreamEvent('stream-1', { type: 'content', data: 'world' })
-
-    const allEvents = await readStreamEvents('stream-1', 0)
-    expect(allEvents.map((entry) => entry.event.data)).toEqual(['hello', 'world'])
-
-    const replayed = await readStreamEvents('stream-1', 1)
-    expect(replayed.map((entry) => entry.event.data)).toEqual(['world'])
-  })
-
-  it.concurrent('flushes buffered events for resume', async () => {
-    const writer = createStreamEventWriter('stream-2')
-    await writer.write({ type: 'content', data: 'a' })
-    await writer.write({ type: 'content', data: 'b' })
-    await writer.flush()
-
-    const events = await readStreamEvents('stream-2', 0)
-    expect(events.map((entry) => entry.event.data)).toEqual(['a', 'b'])
-  })
-})
diff --git a/apps/sim/lib/copilot/orchestrator/stream/buffer.ts b/apps/sim/lib/copilot/orchestrator/stream/buffer.ts
deleted file mode 100644
index 526488c9182..00000000000
--- a/apps/sim/lib/copilot/orchestrator/stream/buffer.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { REDIS_COPILOT_STREAM_PREFIX } from '@/lib/copilot/constants'
-import { env } from '@/lib/core/config/env'
-import { getRedisClient } from '@/lib/core/config/redis'
-
-const logger = createLogger('CopilotStreamBuffer')
-
-const STREAM_DEFAULTS = {
-  ttlSeconds: 60 * 60,
-  eventLimit: 5000,
-  reserveBatch: 200,
-  flushIntervalMs: 15,
-  flushMaxBatch: 200,
-}
-
-export type StreamBufferConfig = {
-  ttlSeconds: number
-  eventLimit: number
-  reserveBatch: number
-  flushIntervalMs: number
-  flushMaxBatch: number
-}
-
-const parseNumber = (value: number | string | undefined, fallback: number): number => {
-  if (typeof value === 'number' && Number.isFinite(value)) return value
-  const parsed = Number(value)
-  return Number.isFinite(parsed) ? parsed : fallback
-}
-
-export function getStreamBufferConfig(): StreamBufferConfig {
-  return {
-    ttlSeconds: parseNumber(env.COPILOT_STREAM_TTL_SECONDS, STREAM_DEFAULTS.ttlSeconds),
-    eventLimit: parseNumber(env.COPILOT_STREAM_EVENT_LIMIT, STREAM_DEFAULTS.eventLimit),
-    reserveBatch: parseNumber(env.COPILOT_STREAM_RESERVE_BATCH, STREAM_DEFAULTS.reserveBatch),
-    flushIntervalMs: parseNumber(
-      env.COPILOT_STREAM_FLUSH_INTERVAL_MS,
-      STREAM_DEFAULTS.flushIntervalMs
-    ),
-    flushMaxBatch: parseNumber(env.COPILOT_STREAM_FLUSH_MAX_BATCH, STREAM_DEFAULTS.flushMaxBatch),
-  }
-}
-
-const APPEND_STREAM_EVENT_LUA = `
-local seqKey = KEYS[1]
-local eventsKey = KEYS[2]
-local ttl = tonumber(ARGV[1])
-local limit = tonumber(ARGV[2])
-local streamId = ARGV[3]
-local eventJson = ARGV[4]
-
-local id = redis.call('INCR', seqKey)
-local entry = '{"eventId":' .. id .. ',"streamId":' .. cjson.encode(streamId) .. ',"event":' .. eventJson .. '}'
-redis.call('ZADD', eventsKey, id, entry)
-redis.call('EXPIRE', eventsKey, ttl)
-redis.call('EXPIRE', seqKey, ttl)
-if limit > 0 then
-  redis.call('ZREMRANGEBYRANK', eventsKey, 0, -limit-1)
-end
-return id
-`
-
-function getStreamKeyPrefix(streamId: string) {
-  return `${REDIS_COPILOT_STREAM_PREFIX}${streamId}`
-}
-
-function getEventsKey(streamId: string) {
-  return `${getStreamKeyPrefix(streamId)}:events`
-}
-
-function getSeqKey(streamId: string) {
-  return `${getStreamKeyPrefix(streamId)}:seq`
-}
-
-function getMetaKey(streamId: string) {
-  return `${getStreamKeyPrefix(streamId)}:meta`
-}
-
-export type StreamStatus = 'active' | 'complete' | 'cancelled' | 'error'
-
-export type StreamMeta = {
-  status: StreamStatus
-  userId?: string
-  executionId?: string
-  runId?: string
-  updatedAt?: string
-  error?: string
-}
-
-export type StreamEventEntry = {
-  eventId: number
-  streamId: string
-  event: Record<string, unknown>
-}
-
-export type StreamEventWriter = {
-  write: (event: Record<string, unknown>) => Promise<StreamEventEntry>
-  flush: () => Promise<void>
-  close: () => Promise<void>
-}
-
-export async function resetStreamBuffer(streamId: string): Promise<void> {
-  const redis = getRedisClient()
-  if (!redis) return
-  try {
-    await redis.del(getEventsKey(streamId), getSeqKey(streamId), getMetaKey(streamId))
-  } catch (error) {
-    logger.warn('Failed to reset stream buffer', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-export async function setStreamMeta(streamId: string, meta: StreamMeta): Promise<void> {
-  const redis = getRedisClient()
-  if (!redis) return
-  try {
-    const config = getStreamBufferConfig()
-    const payload: Record<string, string> = {
-      status: meta.status,
-      updatedAt: meta.updatedAt || new Date().toISOString(),
-    }
-    if (meta.userId) payload.userId = meta.userId
-    if (meta.executionId) payload.executionId = meta.executionId
-    if (meta.runId) payload.runId = meta.runId
-    if (meta.error) payload.error = meta.error
-    await redis.hset(getMetaKey(streamId), payload)
-    await redis.expire(getMetaKey(streamId), config.ttlSeconds)
-  } catch (error) {
-    logger.warn('Failed to update stream meta', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-  }
-}
-
-export async function getStreamMeta(streamId: string): Promise<StreamMeta | null> {
-  const redis = getRedisClient()
-  if (!redis) return null
-  try {
-    const meta = await redis.hgetall(getMetaKey(streamId))
-    if (!meta || Object.keys(meta).length === 0) return null
-    return meta as StreamMeta
-  } catch (error) {
-    logger.warn('Failed to read stream meta', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return null
-  }
-}
-
-export async function appendStreamEvent(
-  streamId: string,
-  event: Record<string, unknown>
-): Promise<StreamEventEntry> {
-  const redis = getRedisClient()
-  if (!redis) {
-    return { eventId: 0, streamId, event }
-  }
-
-  try {
-    const config = getStreamBufferConfig()
-    const eventJson = JSON.stringify(event)
-    const nextId = await redis.eval(
-      APPEND_STREAM_EVENT_LUA,
-      2,
-      getSeqKey(streamId),
-      getEventsKey(streamId),
-      config.ttlSeconds,
-      config.eventLimit,
-      streamId,
-      eventJson
-    )
-    const eventId = typeof nextId === 'number' ? nextId : Number(nextId)
-    return { eventId, streamId, event }
-  } catch (error) {
-    logger.warn('Failed to append stream event', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return { eventId: 0, streamId, event }
-  }
-}
-
-export function createStreamEventWriter(streamId: string): StreamEventWriter {
-  const redis = getRedisClient()
-  if (!redis) {
-    return {
-      write: async (event) => ({ eventId: 0, streamId, event }),
-      flush: async () => {},
-      close: async () => {},
-    }
-  }
-
-  const config = getStreamBufferConfig()
-  let pending: StreamEventEntry[] = []
-  let nextEventId = 0
-  let maxReservedId = 0
-  let flushTimer: ReturnType<typeof setTimeout> | null = null
-  const scheduleFlush = () => {
-    if (flushTimer) return
-    flushTimer = setTimeout(() => {
-      flushTimer = null
-      void flush()
-    }, config.flushIntervalMs)
-  }
-
-  const reserveIds = async (minCount: number) => {
-    const reserveCount = Math.max(config.reserveBatch, minCount)
-    const newMax = await redis.incrby(getSeqKey(streamId), reserveCount)
-    const startId = newMax - reserveCount + 1
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      nextEventId = startId
-      maxReservedId = newMax
-    }
-  }
-
-  let flushPromise: Promise<void> | null = null
-  let closed = false
-
-  const doFlush = async () => {
-    if (pending.length === 0) return
-    const batch = pending
-    pending = []
-    try {
-      const key = getEventsKey(streamId)
-      const zaddArgs: (string | number)[] = []
-      for (const entry of batch) {
-        zaddArgs.push(entry.eventId, JSON.stringify(entry))
-      }
-      const pipeline = redis.pipeline()
-      pipeline.zadd(key, ...(zaddArgs as [number, string]))
-      pipeline.expire(key, config.ttlSeconds)
-      pipeline.expire(getSeqKey(streamId), config.ttlSeconds)
-      pipeline.zremrangebyrank(key, 0, -config.eventLimit - 1)
-      await pipeline.exec()
-    } catch (error) {
-      logger.warn('Failed to flush stream events', {
-        streamId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-      pending = batch.concat(pending)
-      if (pending.length > config.eventLimit) {
-        const dropped = pending.length - config.eventLimit
-        pending = pending.slice(-config.eventLimit)
-        logger.warn('Dropped oldest pending stream events due to sustained Redis failure', {
-          streamId,
-          dropped,
-          remaining: pending.length,
-        })
-      }
-    }
-  }
-
-  const flush = async () => {
-    if (flushPromise) {
-      await flushPromise
-      return
-    }
-    flushPromise = doFlush()
-    try {
-      await flushPromise
-    } finally {
-      flushPromise = null
-      if (pending.length > 0) scheduleFlush()
-    }
-  }
-
-  const write = async (event: Record<string, unknown>) => {
-    if (closed) return { eventId: 0, streamId, event }
-    if (nextEventId === 0 || nextEventId > maxReservedId) {
-      await reserveIds(1)
-    }
-    const eventId = nextEventId++
-    const entry: StreamEventEntry = { eventId, streamId, event }
-    pending.push(entry)
-    if (pending.length >= config.flushMaxBatch) {
-      await flush()
-    } else {
-      scheduleFlush()
-    }
-    return entry
-  }
-
-  const close = async () => {
-    closed = true
-    if (flushTimer) {
-      clearTimeout(flushTimer)
-      flushTimer = null
-    }
-    await flush()
-  }
-
-  return { write, flush, close }
-}
-
-export async function readStreamEvents(
-  streamId: string,
-  afterEventId: number
-): Promise<StreamEventEntry[]> {
-  const redis = getRedisClient()
-  if (!redis) return []
-  try {
-    const raw = await redis.zrangebyscore(getEventsKey(streamId), afterEventId + 1, '+inf')
-    return raw
-      .map((entry) => {
-        try {
-          return JSON.parse(entry) as StreamEventEntry
-        } catch {
-          return null
-        }
-      })
-      .filter((entry): entry is StreamEventEntry => Boolean(entry))
-  } catch (error) {
-    logger.warn('Failed to read stream events', {
-      streamId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return []
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/stream/core.ts b/apps/sim/lib/copilot/orchestrator/stream/core.ts
deleted file mode 100644
index 43c0bc342c9..00000000000
--- a/apps/sim/lib/copilot/orchestrator/stream/core.ts
+++ /dev/null
@@ -1,265 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
-import { isPaid } from '@/lib/billing/plan-helpers'
-import { ORCHESTRATION_TIMEOUT_MS } from '@/lib/copilot/constants'
-import {
-  handleSubagentRouting,
-  sseHandlers,
-  subAgentHandlers,
-} from '@/lib/copilot/orchestrator/sse/handlers'
-import { parseSSEStream } from '@/lib/copilot/orchestrator/sse/parser'
-import {
-  normalizeSseEvent,
-  shouldSkipToolCallEvent,
-  shouldSkipToolResultEvent,
-} from '@/lib/copilot/orchestrator/sse/utils'
-import type {
-  ExecutionContext,
-  OrchestratorOptions,
-  SSEEvent,
-  StreamingContext,
-  ToolCallSummary,
-} from '@/lib/copilot/orchestrator/types'
-import { generateId } from '@/lib/core/utils/uuid'
-
-const logger = createLogger('CopilotStreamCore')
-
-/**
- * Options for the shared stream processing loop.
- */
-export interface StreamLoopOptions extends OrchestratorOptions {
-  /**
-   * Called for each normalized event BEFORE standard handler dispatch.
-   * Return true to skip the default handler for this event.
-   */
-  onBeforeDispatch?: (event: SSEEvent, context: StreamingContext) => boolean | undefined
-}
-
-/**
- * Create a fresh StreamingContext.
- */
-export function createStreamingContext(overrides?: Partial<StreamingContext>): StreamingContext {
-  return {
-    chatId: undefined,
-    executionId: undefined,
-    runId: undefined,
-    messageId: generateId(),
-    accumulatedContent: '',
-    contentBlocks: [],
-    toolCalls: new Map(),
-    pendingToolPromises: new Map(),
-    currentThinkingBlock: null,
-    isInThinkingBlock: false,
-    subAgentParentToolCallId: undefined,
-    subAgentParentStack: [],
-    subAgentContent: {},
-    subAgentToolCalls: {},
-    pendingContent: '',
-    streamComplete: false,
-    wasAborted: false,
-    errors: [],
-    ...overrides,
-  }
-}
-
-/**
- * Run the SSE stream processing loop.
- *
- * Handles: fetch -> parse -> normalize -> dedupe -> subagent routing -> handler dispatch.
- * Callers provide the fetch URL/options and can intercept events via onBeforeDispatch.
- */
-export async function runStreamLoop(
-  fetchUrl: string,
-  fetchOptions: RequestInit,
-  context: StreamingContext,
-  execContext: ExecutionContext,
-  options: StreamLoopOptions
-): Promise<void> {
-  const { timeout = ORCHESTRATION_TIMEOUT_MS, abortSignal } = options
-
-  const response = await fetch(fetchUrl, {
-    ...fetchOptions,
-    signal: abortSignal,
-  })
-
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => '')
-
-    if (response.status === 402) {
-      let action = 'upgrade_plan'
-      let message = "You've reached your usage limit. Please upgrade your plan to continue."
-      try {
-        const sub = await getHighestPrioritySubscription(execContext.userId)
-        if (sub && isPaid(sub.plan)) {
-          action = 'increase_limit'
-          message =
-            "You've reached your usage limit for this billing period. Please increase your usage limit to continue."
-        }
-      } catch {
-        // Fall back to upgrade_plan if we can't determine the plan
-      }
-
-      const upgradePayload = JSON.stringify({
-        reason: 'usage_limit',
-        action,
-        message,
-      })
-      const syntheticContent = `<usage_upgrade>${upgradePayload}</usage_upgrade>`
-
-      const syntheticEvents: SSEEvent[] = [
-        { type: 'content', data: syntheticContent as unknown as Record<string, unknown> },
-        { type: 'done', data: {} },
-      ]
-      for (const event of syntheticEvents) {
-        try {
-          await options.onEvent?.(event)
-        } catch {
-          // best-effort forwarding
-        }
-
-        const handler = sseHandlers[event.type]
-        if (handler) {
-          await handler(event, context, execContext, options)
-        }
-        if (context.streamComplete) break
-      }
-      return
-    }
-
-    throw new Error(
-      `Copilot backend error (${response.status}): ${errorText || response.statusText}`
-    )
-  }
-
-  if (!response.body) {
-    throw new Error('Copilot backend response missing body')
-  }
-
-  const reader = response.body.getReader()
-  const decoder = new TextDecoder()
-
-  const timeoutId = setTimeout(() => {
-    context.errors.push('Request timed out')
-    context.streamComplete = true
-    reader.cancel().catch(() => {})
-  }, timeout)
-
-  try {
-    for await (const event of parseSSEStream(reader, decoder, abortSignal)) {
-      if (abortSignal?.aborted) {
-        context.wasAborted = true
-        await reader.cancel().catch(() => {})
-        break
-      }
-
-      const normalizedEvent = normalizeSseEvent(event)
-
-      // Skip duplicate tool events — both forwarding AND handler dispatch.
-      const shouldSkipToolCall = shouldSkipToolCallEvent(normalizedEvent)
-      const shouldSkipToolResult = shouldSkipToolResultEvent(normalizedEvent)
-
-      if (shouldSkipToolCall || shouldSkipToolResult) {
-        continue
-      }
-
-      try {
-        await options.onEvent?.(normalizedEvent)
-      } catch (error) {
-        logger.withMetadata({ messageId: context.messageId }).warn('Failed to forward SSE event', {
-          type: normalizedEvent.type,
-          error: error instanceof Error ? error.message : String(error),
-        })
-      }
-
-      // Let the caller intercept before standard dispatch.
-      if (options.onBeforeDispatch?.(normalizedEvent, context)) {
-        if (context.streamComplete) break
-        continue
-      }
-
-      // Standard subagent start/end handling (stack-based for nested agents).
-      if (normalizedEvent.type === 'subagent_start') {
-        const eventData = normalizedEvent.data as Record<string, unknown> | undefined
-        const toolCallId = eventData?.tool_call_id as string | undefined
-        const subagentName = normalizedEvent.subagent || (eventData?.agent as string | undefined)
-        if (toolCallId) {
-          context.subAgentParentStack.push(toolCallId)
-          context.subAgentParentToolCallId = toolCallId
-          context.subAgentContent[toolCallId] = ''
-          context.subAgentToolCalls[toolCallId] = []
-        }
-        if (subagentName) {
-          context.contentBlocks.push({
-            type: 'subagent',
-            content: subagentName,
-            timestamp: Date.now(),
-          })
-        }
-        continue
-      }
-
-      if (normalizedEvent.type === 'subagent_end') {
-        if (context.subAgentParentStack.length > 0) {
-          context.subAgentParentStack.pop()
-        } else {
-          logger
-            .withMetadata({ messageId: context.messageId })
-            .warn('subagent_end without matching subagent_start')
-        }
-        context.subAgentParentToolCallId =
-          context.subAgentParentStack.length > 0
-            ? context.subAgentParentStack[context.subAgentParentStack.length - 1]
-            : undefined
-        continue
-      }
-
-      // Subagent event routing.
-      if (handleSubagentRouting(normalizedEvent, context)) {
-        const handler = subAgentHandlers[normalizedEvent.type]
-        if (handler) {
-          await handler(normalizedEvent, context, execContext, options)
-        }
-        if (context.streamComplete) break
-        continue
-      }
-
-      // Main event handler dispatch.
-      const handler = sseHandlers[normalizedEvent.type]
-      if (handler) {
-        await handler(normalizedEvent, context, execContext, options)
-      }
-      if (context.streamComplete) break
-    }
-  } finally {
-    if (abortSignal?.aborted) {
-      context.wasAborted = true
-      await reader.cancel().catch(() => {})
-    }
-    clearTimeout(timeoutId)
-  }
-}
-
-/**
- * Build a ToolCallSummary array from the streaming context.
- */
-export function buildToolCallSummaries(context: StreamingContext): ToolCallSummary[] {
-  return Array.from(context.toolCalls.values()).map((toolCall) => {
-    let status = toolCall.status
-    if (toolCall.result && toolCall.result.success !== undefined) {
-      status = toolCall.result.success ? 'success' : 'error'
-    } else if ((status === 'pending' || status === 'executing') && toolCall.error) {
-      status = 'error'
-    }
-
-    return {
-      id: toolCall.id,
-      name: toolCall.name,
-      status,
-      params: toolCall.params,
-      result: toolCall.result?.output,
-      error: toolCall.error,
-      durationMs:
-        toolCall.endTime && toolCall.startTime ? toolCall.endTime - toolCall.startTime : undefined,
-    }
-  })
-}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/deploy.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/deploy.ts
deleted file mode 100644
index f75d6d7fbca..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/deploy.ts
+++ /dev/null
@@ -1,400 +0,0 @@
-import { db } from '@sim/db'
-import { chat, workflowMcpTool } from '@sim/db/schema'
-import { and, eq, isNull } from 'drizzle-orm'
-import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
-import { getBaseUrl } from '@/lib/core/utils/urls'
-import { generateId } from '@/lib/core/utils/uuid'
-import { mcpPubSub } from '@/lib/mcp/pubsub'
-import { generateParameterSchemaForWorkflow } from '@/lib/mcp/workflow-mcp-sync'
-import { sanitizeToolName } from '@/lib/mcp/workflow-tool-schema'
-import {
-  performChatDeploy,
-  performChatUndeploy,
-  performFullDeploy,
-  performFullUndeploy,
-} from '@/lib/workflows/orchestration'
-import { checkChatAccess, checkWorkflowAccessForChatCreation } from '@/app/api/chat/utils'
-import { ensureWorkflowAccess } from '../access'
-import type { DeployApiParams, DeployChatParams, DeployMcpParams } from '../param-types'
-
-export async function executeDeployApi(
-  params: DeployApiParams,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  try {
-    const workflowId = params.workflowId || context.workflowId
-    if (!workflowId) {
-      return { success: false, error: 'workflowId is required' }
-    }
-    const action = params.action === 'undeploy' ? 'undeploy' : 'deploy'
-    const { workflow: workflowRecord } = await ensureWorkflowAccess(
-      workflowId,
-      context.userId,
-      'admin'
-    )
-
-    if (action === 'undeploy') {
-      const result = await performFullUndeploy({ workflowId, userId: context.userId })
-      if (!result.success) {
-        return { success: false, error: result.error || 'Failed to undeploy workflow' }
-      }
-      return { success: true, output: { workflowId, isDeployed: false } }
-    }
-
-    const result = await performFullDeploy({
-      workflowId,
-      userId: context.userId,
-      workflowName: workflowRecord.name || undefined,
-    })
-    if (!result.success) {
-      return { success: false, error: result.error || 'Failed to deploy workflow' }
-    }
-
-    const baseUrl = getBaseUrl()
-    return {
-      success: true,
-      output: {
-        workflowId,
-        isDeployed: true,
-        deployedAt: result.deployedAt,
-        version: result.version,
-        apiEndpoint: `${baseUrl}/api/workflows/${workflowId}/run`,
-        baseUrl,
-      },
-    }
-  } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : String(error) }
-  }
-}
-
-export async function executeDeployChat(
-  params: DeployChatParams,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  try {
-    const workflowId = params.workflowId || context.workflowId
-    if (!workflowId) {
-      return { success: false, error: 'workflowId is required' }
-    }
-
-    const action = params.action === 'undeploy' ? 'undeploy' : 'deploy'
-    if (action === 'undeploy') {
-      const existing = await db
-        .select()
-        .from(chat)
-        .where(and(eq(chat.workflowId, workflowId), isNull(chat.archivedAt)))
-        .limit(1)
-      if (!existing.length) {
-        return { success: false, error: 'No active chat deployment found for this workflow' }
-      }
-      const { hasAccess, workspaceId: chatWorkspaceId } = await checkChatAccess(
-        existing[0].id,
-        context.userId
-      )
-      if (!hasAccess) {
-        return { success: false, error: 'Unauthorized chat access' }
-      }
-      const undeployResult = await performChatUndeploy({
-        chatId: existing[0].id,
-        userId: context.userId,
-        workspaceId: chatWorkspaceId,
-      })
-      if (!undeployResult.success) {
-        return { success: false, error: undeployResult.error || 'Failed to undeploy chat' }
-      }
-      return {
-        success: true,
-        output: {
-          workflowId,
-          success: true,
-          action: 'undeploy',
-          isDeployed: true,
-          isChatDeployed: false,
-        },
-      }
-    }
-
-    const { hasAccess, workflow: workflowRecord } = await checkWorkflowAccessForChatCreation(
-      workflowId,
-      context.userId
-    )
-    if (!hasAccess || !workflowRecord) {
-      return { success: false, error: 'Workflow not found or access denied' }
-    }
-
-    const [existingDeployment] = await db
-      .select()
-      .from(chat)
-      .where(and(eq(chat.workflowId, workflowId), isNull(chat.archivedAt)))
-      .limit(1)
-
-    const identifier = String(params.identifier || existingDeployment?.identifier || '').trim()
-    const title = String(params.title || existingDeployment?.title || '').trim()
-    if (!identifier || !title) {
-      return { success: false, error: 'Chat identifier and title are required' }
-    }
-
-    const identifierPattern = /^[a-z0-9-]+$/
-    if (!identifierPattern.test(identifier)) {
-      return {
-        success: false,
-        error: 'Identifier can only contain lowercase letters, numbers, and hyphens',
-      }
-    }
-
-    const existingIdentifier = await db
-      .select()
-      .from(chat)
-      .where(and(eq(chat.identifier, identifier), isNull(chat.archivedAt)))
-      .limit(1)
-    if (existingIdentifier.length > 0 && existingIdentifier[0].id !== existingDeployment?.id) {
-      return { success: false, error: 'Identifier already in use' }
-    }
-
-    const existingCustomizations =
-      (existingDeployment?.customizations as
-        | { primaryColor?: string; welcomeMessage?: string }
-        | undefined) || {}
-
-    const result = await performChatDeploy({
-      workflowId,
-      userId: context.userId,
-      identifier,
-      title,
-      description: String(params.description || existingDeployment?.description || ''),
-      customizations: {
-        primaryColor:
-          params.customizations?.primaryColor ||
-          existingCustomizations.primaryColor ||
-          'var(--brand-hover)',
-        welcomeMessage:
-          params.customizations?.welcomeMessage ||
-          existingCustomizations.welcomeMessage ||
-          'Hi there! How can I help you today?',
-      },
-      authType: (params.authType || existingDeployment?.authType || 'public') as
-        | 'public'
-        | 'password'
-        | 'email'
-        | 'sso',
-      password: params.password,
-      allowedEmails: params.allowedEmails || (existingDeployment?.allowedEmails as string[]) || [],
-      outputConfigs: (params.outputConfigs || existingDeployment?.outputConfigs || []) as Array<{
-        blockId: string
-        path: string
-      }>,
-      workspaceId: workflowRecord.workspaceId,
-    })
-
-    if (!result.success) {
-      return { success: false, error: result.error || 'Failed to deploy chat' }
-    }
-
-    const baseUrl = getBaseUrl()
-    return {
-      success: true,
-      output: {
-        workflowId,
-        success: true,
-        action: 'deploy',
-        isDeployed: true,
-        isChatDeployed: true,
-        identifier,
-        chatUrl: result.chatUrl,
-        apiEndpoint: `${baseUrl}/api/workflows/${workflowId}/run`,
-        baseUrl,
-      },
-    }
-  } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : String(error) }
-  }
-}
-
-export async function executeDeployMcp(
-  params: DeployMcpParams,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  try {
-    const workflowId = params.workflowId || context.workflowId
-    if (!workflowId) {
-      return { success: false, error: 'workflowId is required' }
-    }
-
-    const { workflow: workflowRecord } = await ensureWorkflowAccess(
-      workflowId,
-      context.userId,
-      'admin'
-    )
-    const workspaceId = workflowRecord.workspaceId
-    if (!workspaceId) {
-      return { success: false, error: 'workspaceId is required' }
-    }
-
-    const serverId = params.serverId
-    if (!serverId) {
-      return {
-        success: false,
-        error: 'serverId is required. Use list_workspace_mcp_servers to get available servers.',
-      }
-    }
-
-    // Handle undeploy action — remove workflow from MCP server
-    if (params.action === 'undeploy') {
-      const deleted = await db
-        .delete(workflowMcpTool)
-        .where(
-          and(eq(workflowMcpTool.serverId, serverId), eq(workflowMcpTool.workflowId, workflowId))
-        )
-        .returning({ id: workflowMcpTool.id })
-
-      if (deleted.length === 0) {
-        return { success: false, error: 'Workflow is not deployed to this MCP server' }
-      }
-
-      mcpPubSub?.publishWorkflowToolsChanged({ serverId, workspaceId })
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_REMOVED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: serverId,
-        description: `Undeployed workflow "${workflowId}" from MCP server`,
-        metadata: { workflowId, source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: { workflowId, serverId, action: 'undeploy', removed: true },
-      }
-    }
-
-    if (!workflowRecord.isDeployed) {
-      return {
-        success: false,
-        error: 'Workflow must be deployed before adding as an MCP tool. Use deploy_api first.',
-      }
-    }
-
-    const existingTool = await db
-      .select()
-      .from(workflowMcpTool)
-      .where(
-        and(
-          eq(workflowMcpTool.serverId, serverId),
-          eq(workflowMcpTool.workflowId, workflowId),
-          isNull(workflowMcpTool.archivedAt)
-        )
-      )
-      .limit(1)
-
-    const toolName = sanitizeToolName(
-      params.toolName || workflowRecord.name || `workflow_${workflowId}`
-    )
-    const toolDescription =
-      params.toolDescription ||
-      workflowRecord.description ||
-      `Execute ${workflowRecord.name} workflow`
-    const parameterSchema =
-      params.parameterSchema && Object.keys(params.parameterSchema).length > 0
-        ? params.parameterSchema
-        : await generateParameterSchemaForWorkflow(workflowId)
-
-    const baseUrl = getBaseUrl()
-    const mcpServerUrl = `${baseUrl}/api/mcp/serve/${serverId}`
-
-    if (existingTool.length > 0) {
-      const toolId = existingTool[0].id
-      await db
-        .update(workflowMcpTool)
-        .set({
-          toolName,
-          toolDescription,
-          parameterSchema,
-          updatedAt: new Date(),
-        })
-        .where(eq(workflowMcpTool.id, toolId))
-
-      mcpPubSub?.publishWorkflowToolsChanged({ serverId, workspaceId })
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_UPDATED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: serverId,
-        description: `Updated MCP tool "${toolName}" on server`,
-        metadata: { workflowId, toolName, source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: { toolId, toolName, toolDescription, updated: true, mcpServerUrl, baseUrl },
-      }
-    }
-
-    const toolId = generateId()
-    await db.insert(workflowMcpTool).values({
-      id: toolId,
-      serverId,
-      workflowId,
-      toolName,
-      toolDescription,
-      parameterSchema,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    })
-
-    mcpPubSub?.publishWorkflowToolsChanged({ serverId, workspaceId })
-
-    recordAudit({
-      workspaceId,
-      actorId: context.userId,
-      action: AuditAction.MCP_SERVER_ADDED,
-      resourceType: AuditResourceType.MCP_SERVER,
-      resourceId: serverId,
-      description: `Deployed workflow as MCP tool "${toolName}"`,
-      metadata: { workflowId, toolName, toolId, source: 'copilot' },
-    })
-
-    return {
-      success: true,
-      output: { toolId, toolName, toolDescription, updated: false, mcpServerUrl, baseUrl },
-    }
-  } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : String(error) }
-  }
-}
-
-export async function executeRedeploy(
-  params: { workflowId?: string },
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  try {
-    const workflowId = params.workflowId || context.workflowId
-    if (!workflowId) {
-      return { success: false, error: 'workflowId is required' }
-    }
-    await ensureWorkflowAccess(workflowId, context.userId, 'admin')
-
-    const result = await performFullDeploy({ workflowId, userId: context.userId })
-    if (!result.success) {
-      return { success: false, error: result.error || 'Failed to redeploy workflow' }
-    }
-    const baseUrl = getBaseUrl()
-    return {
-      success: true,
-      output: {
-        workflowId,
-        isDeployed: true,
-        deployedAt: result.deployedAt || null,
-        version: result.version,
-        apiEndpoint: `${baseUrl}/api/workflows/${workflowId}/run`,
-        baseUrl,
-      },
-    }
-  } catch (error) {
-    return { success: false, error: error instanceof Error ? error.message : String(error) }
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/index.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/index.ts
deleted file mode 100644
index 9e490922b12..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './deploy'
-export * from './manage'
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/index.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/index.ts
deleted file mode 100644
index ac48a677081..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/index.ts
+++ /dev/null
@@ -1,1528 +0,0 @@
-import { db } from '@sim/db'
-import { credential, mcpServers, pendingCredentialDraft, user } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { and, eq, isNull, lt } from 'drizzle-orm'
-import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import type {
-  ExecutionContext,
-  ToolCallResult,
-  ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { routeExecution } from '@/lib/copilot/tools/server/router'
-import { env } from '@/lib/core/config/env'
-import { getBaseUrl } from '@/lib/core/utils/urls'
-import { generateId } from '@/lib/core/utils/uuid'
-import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { getKnowledgeBaseById } from '@/lib/knowledge/service'
-import { validateMcpDomain } from '@/lib/mcp/domain-check'
-import { mcpService } from '@/lib/mcp/service'
-import { generateMcpServerId } from '@/lib/mcp/utils'
-import { getAllOAuthServices } from '@/lib/oauth/utils'
-import { getTableById } from '@/lib/table/service'
-import { getWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
-import {
-  deleteCustomTool,
-  getCustomToolById,
-  listCustomTools,
-  upsertCustomTools,
-} from '@/lib/workflows/custom-tools/operations'
-import { deleteSkill, listSkills, upsertSkills } from '@/lib/workflows/skills/operations'
-import { getWorkflowById } from '@/lib/workflows/utils'
-import { isMcpTool, isUuid } from '@/executor/constants'
-import { executeTool } from '@/tools'
-import { getTool, resolveToolId } from '@/tools/utils'
-import {
-  executeCheckDeploymentStatus,
-  executeCreateWorkspaceMcpServer,
-  executeDeleteWorkspaceMcpServer,
-  executeDeployApi,
-  executeDeployChat,
-  executeDeployMcp,
-  executeGetDeploymentVersion,
-  executeListWorkspaceMcpServers,
-  executeRedeploy,
-  executeRevertToVersion,
-  executeUpdateWorkspaceMcpServer,
-} from './deployment-tools'
-import { executeIntegrationToolDirect } from './integration-tools'
-import {
-  executeCompleteJob,
-  executeCreateJob,
-  executeManageJob,
-  executeUpdateJobHistory,
-} from './job-tools'
-import { executeMaterializeFile } from './materialize-file'
-import type {
-  CheckDeploymentStatusParams,
-  CreateFolderParams,
-  CreateWorkflowParams,
-  CreateWorkspaceMcpServerParams,
-  DeleteFolderParams,
-  DeleteWorkflowParams,
-  DeleteWorkspaceMcpServerParams,
-  DeployApiParams,
-  DeployChatParams,
-  DeployMcpParams,
-  GenerateApiKeyParams,
-  GetBlockOutputsParams,
-  GetBlockUpstreamReferencesParams,
-  GetDeployedWorkflowStateParams,
-  GetWorkflowDataParams,
-  ListFoldersParams,
-  ListWorkspaceMcpServersParams,
-  MoveFolderParams,
-  MoveWorkflowParams,
-  OpenResourceParams,
-  OpenResourceType,
-  RenameFolderParams,
-  RenameWorkflowParams,
-  RunBlockParams,
-  RunFromBlockParams,
-  RunWorkflowParams,
-  RunWorkflowUntilBlockParams,
-  SetGlobalWorkflowVariablesParams,
-  UpdateWorkflowParams,
-  UpdateWorkspaceMcpServerParams,
-  ValidOpenResourceParams,
-} from './param-types'
-import { PLATFORM_ACTIONS_CONTENT } from './platform-actions'
-import { executeVfsGlob, executeVfsGrep, executeVfsList, executeVfsRead } from './vfs-tools'
-import {
-  executeCreateFolder,
-  executeCreateWorkflow,
-  executeDeleteFolder,
-  executeDeleteWorkflow,
-  executeGenerateApiKey,
-  executeGetBlockOutputs,
-  executeGetBlockUpstreamReferences,
-  executeGetDeployedWorkflowState,
-  executeGetWorkflowData,
-  executeListFolders,
-  executeListUserWorkspaces,
-  executeMoveFolder,
-  executeMoveWorkflow,
-  executeRenameFolder,
-  executeRenameWorkflow,
-  executeRunBlock,
-  executeRunFromBlock,
-  executeRunWorkflow,
-  executeRunWorkflowUntilBlock,
-  executeSetGlobalWorkflowVariables,
-  executeUpdateWorkflow,
-} from './workflow-tools'
-
-const logger = createLogger('CopilotToolExecutor')
-const VALID_OPEN_RESOURCE_TYPES = new Set<OpenResourceType>([
-  'workflow',
-  'table',
-  'knowledgebase',
-  'file',
-])
-
-function validateOpenResourceParams(
-  params: OpenResourceParams
-): { success: true; params: ValidOpenResourceParams } | { success: false; error: string } {
-  if (!params.type) {
-    return { success: false, error: 'type is required' }
-  }
-
-  if (!VALID_OPEN_RESOURCE_TYPES.has(params.type)) {
-    return { success: false, error: `Invalid resource type: ${params.type}` }
-  }
-
-  if (!params.id) {
-    return { success: false, error: `${params.type} resources require \`id\`` }
-  }
-
-  return {
-    success: true,
-    params: {
-      type: params.type,
-      id: params.id,
-    },
-  }
-}
-
-type ManageCustomToolOperation = 'add' | 'edit' | 'delete' | 'list'
-
-interface ManageCustomToolSchema {
-  type: 'function'
-  function: {
-    name: string
-    description?: string
-    parameters: Record<string, unknown>
-  }
-}
-
-interface ManageCustomToolParams {
-  operation?: string
-  toolId?: string
-  schema?: ManageCustomToolSchema
-  code?: string
-  title?: string
-  workspaceId?: string
-}
-
-async function executeManageCustomTool(
-  rawParams: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const params = rawParams as ManageCustomToolParams
-  const operation = String(params.operation || '').toLowerCase() as ManageCustomToolOperation
-  const workspaceId = params.workspaceId || context.workspaceId
-
-  if (!operation) {
-    return { success: false, error: "Missing required 'operation' argument" }
-  }
-
-  const writeOps: string[] = ['add', 'edit', 'delete']
-  if (
-    writeOps.includes(operation) &&
-    context.userPermission &&
-    context.userPermission !== 'write' &&
-    context.userPermission !== 'admin'
-  ) {
-    return {
-      success: false,
-      error: `Permission denied: '${operation}' on manage_custom_tool requires write access. You have '${context.userPermission}' permission.`,
-    }
-  }
-
-  try {
-    if (operation === 'list') {
-      const toolsForUser = await listCustomTools({
-        userId: context.userId,
-        workspaceId,
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          tools: toolsForUser,
-          count: toolsForUser.length,
-        },
-      }
-    }
-
-    if (operation === 'add') {
-      if (!workspaceId) {
-        return {
-          success: false,
-          error: "workspaceId is required for operation 'add'",
-        }
-      }
-      if (!params.schema || !params.code) {
-        return {
-          success: false,
-          error: "Both 'schema' and 'code' are required for operation 'add'",
-        }
-      }
-
-      const title = params.title || params.schema.function?.name
-      if (!title) {
-        return { success: false, error: "Missing tool title or schema.function.name for 'add'" }
-      }
-
-      const resultTools = await upsertCustomTools({
-        tools: [{ title, schema: params.schema, code: params.code }],
-        workspaceId,
-        userId: context.userId,
-      })
-      const created = resultTools.find((tool) => tool.title === title)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.CUSTOM_TOOL_CREATED,
-        resourceType: AuditResourceType.CUSTOM_TOOL,
-        resourceId: created?.id,
-        resourceName: title,
-        description: `Created custom tool "${title}"`,
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          toolId: created?.id,
-          title,
-          message: `Created custom tool "${title}"`,
-        },
-      }
-    }
-
-    if (operation === 'edit') {
-      if (!workspaceId) {
-        return {
-          success: false,
-          error: "workspaceId is required for operation 'edit'",
-        }
-      }
-      if (!params.toolId) {
-        return { success: false, error: "'toolId' is required for operation 'edit'" }
-      }
-      if (!params.schema && !params.code) {
-        return {
-          success: false,
-          error: "At least one of 'schema' or 'code' is required for operation 'edit'",
-        }
-      }
-
-      const existing = await getCustomToolById({
-        toolId: params.toolId,
-        userId: context.userId,
-        workspaceId,
-      })
-      if (!existing) {
-        return { success: false, error: `Custom tool not found: ${params.toolId}` }
-      }
-
-      const mergedSchema = params.schema || (existing.schema as ManageCustomToolSchema)
-      const mergedCode = params.code || existing.code
-      const title = params.title || mergedSchema.function?.name || existing.title
-
-      await upsertCustomTools({
-        tools: [{ id: params.toolId, title, schema: mergedSchema, code: mergedCode }],
-        workspaceId,
-        userId: context.userId,
-      })
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.CUSTOM_TOOL_UPDATED,
-        resourceType: AuditResourceType.CUSTOM_TOOL,
-        resourceId: params.toolId,
-        resourceName: title,
-        description: `Updated custom tool "${title}"`,
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          toolId: params.toolId,
-          title,
-          message: `Updated custom tool "${title}"`,
-        },
-      }
-    }
-
-    if (operation === 'delete') {
-      if (!params.toolId) {
-        return { success: false, error: "'toolId' is required for operation 'delete'" }
-      }
-
-      const deleted = await deleteCustomTool({
-        toolId: params.toolId,
-        userId: context.userId,
-        workspaceId,
-      })
-      if (!deleted) {
-        return { success: false, error: `Custom tool not found: ${params.toolId}` }
-      }
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.CUSTOM_TOOL_DELETED,
-        resourceType: AuditResourceType.CUSTOM_TOOL,
-        resourceId: params.toolId,
-        description: 'Deleted custom tool',
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          toolId: params.toolId,
-          message: 'Deleted custom tool',
-        },
-      }
-    }
-
-    return {
-      success: false,
-      error: `Unsupported operation for manage_custom_tool: ${operation}`,
-    }
-  } catch (error) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('manage_custom_tool execution failed', {
-        operation,
-        workspaceId,
-        userId: context.userId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to manage custom tool',
-    }
-  }
-}
-
-type ManageMcpToolOperation = 'add' | 'edit' | 'delete' | 'list'
-
-interface ManageMcpToolConfig {
-  name?: string
-  transport?: string
-  url?: string
-  headers?: Record<string, string>
-  timeout?: number
-  enabled?: boolean
-}
-
-interface ManageMcpToolParams {
-  operation?: string
-  serverId?: string
-  config?: ManageMcpToolConfig
-}
-
-async function executeManageMcpTool(
-  rawParams: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const params = rawParams as ManageMcpToolParams
-  const operation = String(params.operation || '').toLowerCase() as ManageMcpToolOperation
-  const workspaceId = context.workspaceId
-
-  if (!operation) {
-    return { success: false, error: "Missing required 'operation' argument" }
-  }
-
-  if (!workspaceId) {
-    return { success: false, error: 'workspaceId is required' }
-  }
-
-  const writeOps: string[] = ['add', 'edit', 'delete']
-  if (
-    writeOps.includes(operation) &&
-    context.userPermission &&
-    context.userPermission !== 'write' &&
-    context.userPermission !== 'admin'
-  ) {
-    return {
-      success: false,
-      error: `Permission denied: '${operation}' on manage_mcp_tool requires write access. You have '${context.userPermission}' permission.`,
-    }
-  }
-
-  try {
-    if (operation === 'list') {
-      const servers = await db
-        .select()
-        .from(mcpServers)
-        .where(and(eq(mcpServers.workspaceId, workspaceId), isNull(mcpServers.deletedAt)))
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          servers: servers.map((s) => ({
-            id: s.id,
-            name: s.name,
-            url: s.url,
-            transport: s.transport,
-            enabled: s.enabled,
-            connectionStatus: s.connectionStatus,
-          })),
-          count: servers.length,
-        },
-      }
-    }
-
-    if (operation === 'add') {
-      const config = params.config
-      if (!config?.name || !config?.url) {
-        return { success: false, error: "config.name and config.url are required for 'add'" }
-      }
-
-      validateMcpDomain(config.url)
-
-      const serverId = generateMcpServerId(workspaceId, config.url)
-
-      const [existing] = await db
-        .select({ id: mcpServers.id, deletedAt: mcpServers.deletedAt })
-        .from(mcpServers)
-        .where(and(eq(mcpServers.id, serverId), eq(mcpServers.workspaceId, workspaceId)))
-        .limit(1)
-
-      if (existing) {
-        await db
-          .update(mcpServers)
-          .set({
-            name: config.name,
-            transport: config.transport || 'streamable-http',
-            url: config.url,
-            headers: config.headers || {},
-            timeout: config.timeout || 30000,
-            enabled: config.enabled !== false,
-            connectionStatus: 'connected',
-            lastConnected: new Date(),
-            updatedAt: new Date(),
-            deletedAt: null,
-          })
-          .where(eq(mcpServers.id, serverId))
-      } else {
-        await db.insert(mcpServers).values({
-          id: serverId,
-          workspaceId,
-          createdBy: context.userId,
-          name: config.name,
-          description: '',
-          transport: config.transport || 'streamable-http',
-          url: config.url,
-          headers: config.headers || {},
-          timeout: config.timeout || 30000,
-          retries: 3,
-          enabled: config.enabled !== false,
-          connectionStatus: 'connected',
-          lastConnected: new Date(),
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        })
-      }
-
-      await mcpService.clearCache(workspaceId)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_ADDED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: serverId,
-        resourceName: config.name,
-        description: existing
-          ? `Updated existing MCP server "${config.name}"`
-          : `Added MCP server "${config.name}"`,
-        metadata: { transport: config.transport, url: config.url, source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          serverId,
-          name: config.name,
-          message: existing
-            ? `Updated existing MCP server "${config.name}"`
-            : `Added MCP server "${config.name}"`,
-        },
-      }
-    }
-
-    if (operation === 'edit') {
-      if (!params.serverId) {
-        return { success: false, error: "'serverId' is required for 'edit'" }
-      }
-      const config = params.config
-      if (!config) {
-        return { success: false, error: "'config' is required for 'edit'" }
-      }
-
-      if (config.url) {
-        validateMcpDomain(config.url)
-      }
-
-      const updateData: Record<string, unknown> = { updatedAt: new Date() }
-      if (config.name !== undefined) updateData.name = config.name
-      if (config.transport !== undefined) updateData.transport = config.transport
-      if (config.url !== undefined) updateData.url = config.url
-      if (config.headers !== undefined) updateData.headers = config.headers
-      if (config.timeout !== undefined) updateData.timeout = config.timeout
-      if (config.enabled !== undefined) updateData.enabled = config.enabled
-
-      const [updated] = await db
-        .update(mcpServers)
-        .set(updateData)
-        .where(
-          and(
-            eq(mcpServers.id, params.serverId),
-            eq(mcpServers.workspaceId, workspaceId),
-            isNull(mcpServers.deletedAt)
-          )
-        )
-        .returning()
-
-      if (!updated) {
-        return { success: false, error: `MCP server not found: ${params.serverId}` }
-      }
-
-      await mcpService.clearCache(workspaceId)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_UPDATED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: params.serverId,
-        resourceName: updated.name,
-        description: `Updated MCP server "${updated.name}"`,
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          serverId: params.serverId,
-          name: updated.name,
-          message: `Updated MCP server "${updated.name}"`,
-        },
-      }
-    }
-
-    if (operation === 'delete') {
-      if (context.userPermission && context.userPermission !== 'admin') {
-        return {
-          success: false,
-          error: `Permission denied: 'delete' on manage_mcp_tool requires admin access. You have '${context.userPermission}' permission.`,
-        }
-      }
-
-      if (!params.serverId) {
-        return { success: false, error: "'serverId' is required for 'delete'" }
-      }
-
-      const [deleted] = await db
-        .delete(mcpServers)
-        .where(and(eq(mcpServers.id, params.serverId), eq(mcpServers.workspaceId, workspaceId)))
-        .returning()
-
-      if (!deleted) {
-        return { success: false, error: `MCP server not found: ${params.serverId}` }
-      }
-
-      await mcpService.clearCache(workspaceId)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.MCP_SERVER_REMOVED,
-        resourceType: AuditResourceType.MCP_SERVER,
-        resourceId: params.serverId,
-        resourceName: deleted.name,
-        description: `Deleted MCP server "${deleted.name}"`,
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          serverId: params.serverId,
-          message: `Deleted MCP server "${deleted.name}"`,
-        },
-      }
-    }
-
-    return { success: false, error: `Unsupported operation for manage_mcp_tool: ${operation}` }
-  } catch (error) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .error('manage_mcp_tool execution failed', {
-        operation,
-        workspaceId,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to manage MCP server',
-    }
-  }
-}
-
-type ManageSkillOperation = 'add' | 'edit' | 'delete' | 'list'
-
-interface ManageSkillParams {
-  operation?: string
-  skillId?: string
-  name?: string
-  description?: string
-  content?: string
-}
-
-async function executeManageSkill(
-  rawParams: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const params = rawParams as ManageSkillParams
-  const operation = String(params.operation || '').toLowerCase() as ManageSkillOperation
-  const workspaceId = context.workspaceId
-
-  if (!operation) {
-    return { success: false, error: "Missing required 'operation' argument" }
-  }
-
-  if (!workspaceId) {
-    return { success: false, error: 'workspaceId is required' }
-  }
-
-  const writeOps: string[] = ['add', 'edit', 'delete']
-  if (
-    writeOps.includes(operation) &&
-    context.userPermission &&
-    context.userPermission !== 'write' &&
-    context.userPermission !== 'admin'
-  ) {
-    return {
-      success: false,
-      error: `Permission denied: '${operation}' on manage_skill requires write access. You have '${context.userPermission}' permission.`,
-    }
-  }
-
-  try {
-    if (operation === 'list') {
-      const skills = await listSkills({ workspaceId })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skills: skills.map((s) => ({
-            id: s.id,
-            name: s.name,
-            description: s.description,
-            createdAt: s.createdAt,
-          })),
-          count: skills.length,
-        },
-      }
-    }
-
-    if (operation === 'add') {
-      if (!params.name || !params.description || !params.content) {
-        return {
-          success: false,
-          error: "'name', 'description', and 'content' are required for 'add'",
-        }
-      }
-
-      const resultSkills = await upsertSkills({
-        skills: [{ name: params.name, description: params.description, content: params.content }],
-        workspaceId,
-        userId: context.userId,
-      })
-      const created = resultSkills.find((s) => s.name === params.name)
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.SKILL_CREATED,
-        resourceType: AuditResourceType.SKILL,
-        resourceId: created?.id,
-        resourceName: params.name,
-        description: `Created skill "${params.name}"`,
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skillId: created?.id,
-          name: params.name,
-          message: `Created skill "${params.name}"`,
-        },
-      }
-    }
-
-    if (operation === 'edit') {
-      if (!params.skillId) {
-        return { success: false, error: "'skillId' is required for 'edit'" }
-      }
-      if (!params.name && !params.description && !params.content) {
-        return {
-          success: false,
-          error: "At least one of 'name', 'description', or 'content' is required for 'edit'",
-        }
-      }
-
-      const existing = await listSkills({ workspaceId })
-      const found = existing.find((s) => s.id === params.skillId)
-      if (!found) {
-        return { success: false, error: `Skill not found: ${params.skillId}` }
-      }
-
-      await upsertSkills({
-        skills: [
-          {
-            id: params.skillId,
-            name: params.name || found.name,
-            description: params.description || found.description,
-            content: params.content || found.content,
-          },
-        ],
-        workspaceId,
-        userId: context.userId,
-      })
-
-      const updatedName = params.name || found.name
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.SKILL_UPDATED,
-        resourceType: AuditResourceType.SKILL,
-        resourceId: params.skillId,
-        resourceName: updatedName,
-        description: `Updated skill "${updatedName}"`,
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skillId: params.skillId,
-          name: updatedName,
-          message: `Updated skill "${updatedName}"`,
-        },
-      }
-    }
-
-    if (operation === 'delete') {
-      if (!params.skillId) {
-        return { success: false, error: "'skillId' is required for 'delete'" }
-      }
-
-      const deleted = await deleteSkill({ skillId: params.skillId, workspaceId })
-      if (!deleted) {
-        return { success: false, error: `Skill not found: ${params.skillId}` }
-      }
-
-      recordAudit({
-        workspaceId,
-        actorId: context.userId,
-        action: AuditAction.SKILL_DELETED,
-        resourceType: AuditResourceType.SKILL,
-        resourceId: params.skillId,
-        description: 'Deleted skill',
-        metadata: { source: 'copilot' },
-      })
-
-      return {
-        success: true,
-        output: {
-          success: true,
-          operation,
-          skillId: params.skillId,
-          message: 'Deleted skill',
-        },
-      }
-    }
-
-    return { success: false, error: `Unsupported operation for manage_skill: ${operation}` }
-  } catch (error) {
-    logger.withMetadata({ messageId: context.messageId }).error('manage_skill execution failed', {
-      operation,
-      workspaceId,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to manage skill',
-    }
-  }
-}
-
-const SERVER_TOOLS = new Set<string>([
-  'get_blocks_metadata',
-  'get_trigger_blocks',
-  'edit_workflow',
-  'get_workflow_logs',
-  'search_documentation',
-  'set_environment_variables',
-  'make_api_request',
-  'knowledge_base',
-  'user_table',
-  'workspace_file',
-  'download_to_workspace_file',
-  'get_execution_summary',
-  'get_job_logs',
-  'generate_visualization',
-  'generate_image',
-])
-
-/**
- * Resolves a human-friendly provider name to a providerId and generates the
- * actual OAuth authorization URL via Better Auth's server-side API.
- *
- * Steps: resolve provider → create credential draft → look up user session →
- * call auth.api.oAuth2LinkAccount → return the real authorization URL.
- */
-async function generateOAuthLink(
-  userId: string,
-  workspaceId: string | undefined,
-  workflowId: string | undefined,
-  chatId: string | undefined,
-  providerName: string,
-  baseUrl: string
-): Promise<{ url: string; providerId: string; serviceName: string }> {
-  if (!workspaceId) {
-    throw new Error('workspaceId is required to generate an OAuth link')
-  }
-
-  const allServices = getAllOAuthServices()
-  const normalizedInput = providerName.toLowerCase().trim()
-
-  const matched =
-    allServices.find((s) => s.providerId === normalizedInput) ||
-    allServices.find((s) => s.name.toLowerCase() === normalizedInput) ||
-    allServices.find(
-      (s) =>
-        s.name.toLowerCase().includes(normalizedInput) ||
-        normalizedInput.includes(s.name.toLowerCase())
-    ) ||
-    allServices.find(
-      (s) => s.providerId.includes(normalizedInput) || normalizedInput.includes(s.providerId)
-    )
-
-  if (!matched) {
-    const available = allServices.map((s) => s.name).join(', ')
-    throw new Error(`Provider "${providerName}" not found. Available providers: ${available}`)
-  }
-
-  const { providerId, name: serviceName } = matched
-  const callbackURL =
-    workflowId && workspaceId
-      ? `${baseUrl}/workspace/${workspaceId}/w/${workflowId}`
-      : chatId && workspaceId
-        ? `${baseUrl}/workspace/${workspaceId}/task/${chatId}`
-        : `${baseUrl}/workspace/${workspaceId}`
-
-  // Trello and Shopify use custom auth routes, not genericOAuth
-  if (providerId === 'trello') {
-    return { url: `${baseUrl}/api/auth/trello/authorize`, providerId, serviceName }
-  }
-  if (providerId === 'shopify') {
-    const returnUrl = encodeURIComponent(callbackURL)
-    return {
-      url: `${baseUrl}/api/auth/shopify/authorize?returnUrl=${returnUrl}`,
-      providerId,
-      serviceName,
-    }
-  }
-
-  // Build display name: "User Name's ServiceName" or just "ServiceName"
-  let displayName = serviceName
-  try {
-    const [row] = await db.select({ name: user.name }).from(user).where(eq(user.id, userId))
-    if (row?.name) {
-      displayName = `${row.name}'s ${serviceName}`
-    }
-  } catch {
-    // Fall back to service name only
-  }
-
-  // Create credential draft so the callback hook creates the credential
-  const now = new Date()
-  await db
-    .delete(pendingCredentialDraft)
-    .where(
-      and(eq(pendingCredentialDraft.userId, userId), lt(pendingCredentialDraft.expiresAt, now))
-    )
-  await db
-    .insert(pendingCredentialDraft)
-    .values({
-      id: generateId(),
-      userId,
-      workspaceId,
-      providerId,
-      displayName,
-      expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
-      createdAt: now,
-    })
-    .onConflictDoUpdate({
-      target: [
-        pendingCredentialDraft.userId,
-        pendingCredentialDraft.providerId,
-        pendingCredentialDraft.workspaceId,
-      ],
-      set: {
-        displayName,
-        expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
-        createdAt: now,
-      },
-    })
-
-  const { auth } = await import('@/lib/auth/auth')
-  const { headers: getHeaders } = await import('next/headers')
-  const reqHeaders = await getHeaders()
-
-  const data = await auth.api.oAuth2LinkAccount({
-    body: { providerId, callbackURL },
-    headers: reqHeaders,
-  })
-
-  if (!data?.url) {
-    throw new Error('oAuth2LinkAccount did not return an authorization URL')
-  }
-
-  return { url: data.url, providerId, serviceName }
-}
-
-const SIM_WORKFLOW_TOOL_HANDLERS: Record<
-  string,
-  (params: Record<string, unknown>, context: ExecutionContext) => Promise<ToolCallResult>
-> = {
-  list_user_workspaces: (_p, c) => executeListUserWorkspaces(c),
-  list_folders: (p, c) => executeListFolders(p as ListFoldersParams, c),
-  create_workflow: (p, c) => executeCreateWorkflow(p as CreateWorkflowParams, c),
-  create_folder: (p, c) => executeCreateFolder(p as CreateFolderParams, c),
-  rename_workflow: (p, c) => executeRenameWorkflow(p as unknown as RenameWorkflowParams, c),
-  update_workflow: (p, c) => executeUpdateWorkflow(p as unknown as UpdateWorkflowParams, c),
-  delete_workflow: (p, c) => executeDeleteWorkflow(p as unknown as DeleteWorkflowParams, c),
-  move_workflow: (p, c) => executeMoveWorkflow(p as unknown as MoveWorkflowParams, c),
-  move_folder: (p, c) => executeMoveFolder(p as unknown as MoveFolderParams, c),
-  rename_folder: (p, c) => executeRenameFolder(p as unknown as RenameFolderParams, c),
-  delete_folder: (p, c) => executeDeleteFolder(p as unknown as DeleteFolderParams, c),
-  get_workflow_data: (p, c) => executeGetWorkflowData(p as GetWorkflowDataParams, c),
-  get_block_outputs: (p, c) => executeGetBlockOutputs(p as GetBlockOutputsParams, c),
-  get_block_upstream_references: (p, c) =>
-    executeGetBlockUpstreamReferences(p as unknown as GetBlockUpstreamReferencesParams, c),
-  run_workflow: (p, c) => executeRunWorkflow(p as RunWorkflowParams, c),
-  run_workflow_until_block: (p, c) =>
-    executeRunWorkflowUntilBlock(p as unknown as RunWorkflowUntilBlockParams, c),
-  run_from_block: (p, c) => executeRunFromBlock(p as unknown as RunFromBlockParams, c),
-  run_block: (p, c) => executeRunBlock(p as unknown as RunBlockParams, c),
-  get_deployed_workflow_state: (p, c) =>
-    executeGetDeployedWorkflowState(p as GetDeployedWorkflowStateParams, c),
-  generate_api_key: (p, c) => executeGenerateApiKey(p as unknown as GenerateApiKeyParams, c),
-  get_platform_actions: () =>
-    Promise.resolve({
-      success: true,
-      output: { content: PLATFORM_ACTIONS_CONTENT },
-    }),
-  set_global_workflow_variables: (p, c) =>
-    executeSetGlobalWorkflowVariables(p as SetGlobalWorkflowVariablesParams, c),
-  deploy_api: (p, c) => executeDeployApi(p as DeployApiParams, c),
-  deploy_chat: (p, c) => executeDeployChat(p as DeployChatParams, c),
-  deploy_mcp: (p, c) => executeDeployMcp(p as DeployMcpParams, c),
-  redeploy: (p, c) => executeRedeploy(p as { workflowId?: string }, c),
-  check_deployment_status: (p, c) =>
-    executeCheckDeploymentStatus(p as CheckDeploymentStatusParams, c),
-  list_workspace_mcp_servers: (p, c) =>
-    executeListWorkspaceMcpServers(p as ListWorkspaceMcpServersParams, c),
-  create_workspace_mcp_server: (p, c) =>
-    executeCreateWorkspaceMcpServer(p as CreateWorkspaceMcpServerParams, c),
-  update_workspace_mcp_server: (p, c) =>
-    executeUpdateWorkspaceMcpServer(p as unknown as UpdateWorkspaceMcpServerParams, c),
-  delete_workspace_mcp_server: (p, c) =>
-    executeDeleteWorkspaceMcpServer(p as unknown as DeleteWorkspaceMcpServerParams, c),
-  get_deployment_version: (p, c) =>
-    executeGetDeploymentVersion(p as { workflowId?: string; version?: number }, c),
-  revert_to_version: (p, c) =>
-    executeRevertToVersion(p as { workflowId?: string; version?: number }, c),
-  manage_credential: async (p, c) => {
-    const params = p as { operation: string; credentialId: string; displayName?: string }
-    const { operation, credentialId, displayName } = params
-    if (!credentialId) {
-      return { success: false, error: 'credentialId is required' }
-    }
-    try {
-      const [row] = await db
-        .select({ id: credential.id, type: credential.type, displayName: credential.displayName })
-        .from(credential)
-        .where(eq(credential.id, credentialId))
-        .limit(1)
-      if (!row) {
-        return { success: false, error: 'Credential not found' }
-      }
-      if (row.type !== 'oauth') {
-        return {
-          success: false,
-          error:
-            'Only OAuth credentials can be managed with this tool. Use set_environment_variables for env vars.',
-        }
-      }
-      switch (operation) {
-        case 'rename': {
-          if (!displayName) {
-            return { success: false, error: 'displayName is required for rename' }
-          }
-          await db
-            .update(credential)
-            .set({ displayName, updatedAt: new Date() })
-            .where(eq(credential.id, credentialId))
-          recordAudit({
-            actorId: c.userId,
-            action: AuditAction.CREDENTIAL_RENAMED,
-            resourceType: AuditResourceType.OAUTH,
-            resourceId: credentialId,
-            resourceName: displayName,
-            description: `Renamed credential to "${displayName}"`,
-            metadata: { source: 'copilot' },
-          })
-          return { success: true, output: { credentialId, displayName } }
-        }
-        case 'delete': {
-          await db.delete(credential).where(eq(credential.id, credentialId))
-          recordAudit({
-            actorId: c.userId,
-            action: AuditAction.CREDENTIAL_DELETED,
-            resourceType: AuditResourceType.OAUTH,
-            resourceId: credentialId,
-            description: `Deleted credential`,
-            metadata: { source: 'copilot' },
-          })
-          return { success: true, output: { credentialId, deleted: true } }
-        }
-        default:
-          return {
-            success: false,
-            error: `Unknown operation: ${operation}. Use "rename" or "delete".`,
-          }
-      }
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) }
-    }
-  },
-  create_job: (p, c) => executeCreateJob(p, c),
-  manage_job: (p, c) => executeManageJob(p, c),
-  complete_job: (p, c) => executeCompleteJob(p, c),
-  update_job_history: (p, c) => executeUpdateJobHistory(p, c),
-  oauth_get_auth_link: async (p, c) => {
-    const providerName = (p.providerName || p.provider_name || 'the provider') as string
-    const baseUrl = getBaseUrl()
-
-    try {
-      const result = await generateOAuthLink(
-        c.userId,
-        c.workspaceId,
-        c.workflowId,
-        c.chatId,
-        providerName,
-        baseUrl
-      )
-      return {
-        success: true,
-        output: {
-          message: `Authorization URL generated for ${result.serviceName}. The user must open this URL in a browser to authorize.`,
-          oauth_url: result.url,
-          instructions: `Open this URL in your browser to connect ${result.serviceName}: ${result.url}`,
-          provider: result.serviceName,
-          providerId: result.providerId,
-        },
-      }
-    } catch (err) {
-      logger
-        .withMetadata({ messageId: c.messageId })
-        .warn('Failed to generate OAuth link, falling back to generic URL', {
-          providerName,
-          error: err instanceof Error ? err.message : String(err),
-        })
-      const workspaceUrl = c.workspaceId
-        ? `${baseUrl}/workspace/${c.workspaceId}`
-        : `${baseUrl}/workspace`
-      return {
-        success: false,
-        output: {
-          message: `Could not generate a direct OAuth link for ${providerName}. The user can connect manually from the workspace.`,
-          oauth_url: workspaceUrl,
-          instructions: `Open ${workspaceUrl} in a browser, go to Settings → Credentials, and connect ${providerName} from there.`,
-          provider: providerName,
-          error: err instanceof Error ? err.message : String(err),
-        },
-      }
-    }
-  },
-  oauth_request_access: async (p, _c) => {
-    const providerName = (p.providerName || p.provider_name || 'the provider') as string
-    return {
-      success: true,
-      output: {
-        success: true,
-        status: 'requested',
-        providerName,
-        message: `Requested ${providerName} OAuth connection. The user should complete the OAuth modal in the UI, then retry credential-dependent actions.`,
-      },
-    }
-  },
-  materialize_file: (p, c) => executeMaterializeFile(p, c),
-  manage_custom_tool: (p, c) => executeManageCustomTool(p, c),
-  manage_mcp_tool: (p, c) => executeManageMcpTool(p, c),
-  manage_skill: (p, c) => executeManageSkill(p, c),
-  // VFS tools
-  grep: (p, c) => executeVfsGrep(p, c),
-  glob: (p, c) => executeVfsGlob(p, c),
-  read: (p, c) => executeVfsRead(p, c),
-  list: (p, c) => executeVfsList(p, c),
-
-  // Resource visibility
-  open_resource: async (p: OpenResourceParams, c: ExecutionContext) => {
-    const validated = validateOpenResourceParams(p)
-    if (!validated.success) {
-      return { success: false, error: validated.error }
-    }
-
-    const params = validated.params
-    const resourceType = params.type
-    let resourceId = params.id
-    let title: string = resourceType
-
-    if (resourceType === 'file') {
-      if (!c.workspaceId) {
-        return {
-          success: false,
-          error:
-            'Opening a workspace file requires workspace context. Pass the canonical file UUID from files/by-id/<fileId>/meta.json.',
-        }
-      }
-      if (!isUuid(params.id)) {
-        return {
-          success: false,
-          error:
-            'open_resource for files requires the canonical file UUID. Read files/by-id/<fileId>/meta.json or files/<name>/meta.json and pass the "id" field. Do not pass VFS paths or display names.',
-        }
-      }
-      const record = await getWorkspaceFile(c.workspaceId, params.id)
-      if (!record) {
-        return {
-          success: false,
-          error: `No workspace file with id "${params.id}". Confirm the UUID from files/by-id/<fileId>/meta.json.`,
-        }
-      }
-      resourceId = record.id
-      title = record.name
-    }
-
-    if (resourceType === 'workflow') {
-      const workflow = await getWorkflowById(params.id)
-      if (!workflow) {
-        return {
-          success: false,
-          error: `No workflow with id "${params.id}". Confirm the workflow ID before opening it.`,
-        }
-      }
-      if (c.workspaceId && workflow.workspaceId !== c.workspaceId) {
-        return {
-          success: false,
-          error: `Workflow "${params.id}" was not found in the current workspace.`,
-        }
-      }
-      resourceId = workflow.id
-      title = workflow.name
-    }
-
-    if (resourceType === 'table') {
-      const table = await getTableById(params.id)
-      if (!table) {
-        return {
-          success: false,
-          error: `No table with id "${params.id}". Confirm the table ID before opening it.`,
-        }
-      }
-      if (c.workspaceId && table.workspaceId !== c.workspaceId) {
-        return {
-          success: false,
-          error: `Table "${params.id}" was not found in the current workspace.`,
-        }
-      }
-      resourceId = table.id
-      title = table.name
-    }
-
-    if (resourceType === 'knowledgebase') {
-      const knowledgeBase = await getKnowledgeBaseById(params.id)
-      if (!knowledgeBase) {
-        return {
-          success: false,
-          error: `No knowledge base with id "${params.id}". Confirm the knowledge base ID before opening it.`,
-        }
-      }
-      if (c.workspaceId && knowledgeBase.workspaceId !== c.workspaceId) {
-        return {
-          success: false,
-          error: `Knowledge base "${params.id}" was not found in the current workspace.`,
-        }
-      }
-      resourceId = knowledgeBase.id
-      title = knowledgeBase.name
-    }
-
-    return {
-      success: true,
-      output: { message: `Opened ${resourceType} ${resourceId} for the user` },
-      resources: [
-        {
-          type: resourceType as 'workflow' | 'table' | 'knowledgebase' | 'file',
-          id: resourceId,
-          title,
-        },
-      ],
-    }
-  },
-}
-
-/**
- * Check whether a tool can be executed on the Sim (TypeScript) side.
- *
- * Tools that are only available server-side (e.g. search_patterns)
- * will return false.  The subagent tool_call
- * handler uses this to decide whether to execute a tool locally or let the
- * server's own tool_result SSE event handle it.
- */
-export function isToolAvailableOnSimSide(toolName: string): boolean {
-  if (SERVER_TOOLS.has(toolName)) return true
-  if (toolName in SIM_WORKFLOW_TOOL_HANDLERS) return true
-  if (isMcpTool(toolName)) return true
-  const resolvedToolName = resolveToolId(toolName)
-  return !!getTool(resolvedToolName)
-}
-
-/**
- * Execute a tool server-side without calling internal routes.
- */
-export async function executeToolServerSide(
-  toolCall: ToolCallState,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const toolName = toolCall.name
-  const resolvedToolName = resolveToolId(toolName)
-
-  if (SERVER_TOOLS.has(toolName)) {
-    return executeServerToolDirect(toolName, toolCall.params || {}, context)
-  }
-
-  if (toolName in SIM_WORKFLOW_TOOL_HANDLERS) {
-    return executeSimWorkflowTool(toolName, toolCall.params || {}, context)
-  }
-
-  if (isMcpTool(toolName)) {
-    return executeMcpToolDirect(toolCall, context)
-  }
-
-  const toolConfig = getTool(resolvedToolName)
-  if (!toolConfig) {
-    logger
-      .withMetadata({ messageId: context.messageId })
-      .warn('Tool not found in registry', { toolName, resolvedToolName })
-    return {
-      success: false,
-      error: `Tool not found: ${toolName}`,
-    }
-  }
-
-  return executeIntegrationToolDirect(toolCall, toolConfig, context)
-}
-
-/**
- * Execute an MCP tool via the existing executeTool dispatcher which
- * already handles the mcp- prefix and routes to /api/mcp/tools/execute.
- */
-async function executeMcpToolDirect(
-  toolCall: ToolCallState,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const { userId, workflowId } = context
-
-  let workspaceId = context.workspaceId
-  if (!workspaceId && workflowId) {
-    const wf = await getWorkflowById(workflowId)
-    workspaceId = wf?.workspaceId ?? undefined
-  }
-
-  const params: Record<string, unknown> = {
-    ...(toolCall.params || {}),
-    _context: { workflowId, userId, workspaceId },
-  }
-
-  const result = await executeTool(toolCall.name, params)
-
-  return {
-    success: result.success,
-    output: result.output,
-    error: result.error,
-  }
-}
-
-/**
- * Execute a server tool directly via the server tool router.
- */
-async function executeServerToolDirect(
-  toolName: string,
-  params: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  try {
-    const enrichedParams = { ...params }
-    if (!enrichedParams.workflowId && context.workflowId) {
-      enrichedParams.workflowId = context.workflowId
-    }
-    if (!enrichedParams.workspaceId && context.workspaceId) {
-      enrichedParams.workspaceId = context.workspaceId
-    }
-
-    const result = await routeExecution(toolName, enrichedParams, {
-      userId: context.userId,
-      workspaceId: context.workspaceId,
-      userPermission: context.userPermission,
-      chatId: context.chatId,
-      messageId: context.messageId,
-      abortSignal: context.abortSignal,
-      userStopSignal: context.userStopSignal,
-    })
-
-    const resultRecord =
-      result && typeof result === 'object' && !Array.isArray(result)
-        ? (result as Record<string, unknown>)
-        : null
-
-    // Some server tools return an explicit { success, message, ... } envelope.
-    // Preserve tool-level failures instead of reporting them as transport success.
-    if (resultRecord?.success === false) {
-      const message =
-        (typeof resultRecord.error === 'string' && resultRecord.error) ||
-        (typeof resultRecord.message === 'string' && resultRecord.message) ||
-        `${toolName} failed`
-
-      return {
-        success: false,
-        error: message,
-        output: result,
-      }
-    }
-
-    return { success: true, output: result }
-  } catch (error) {
-    logger.withMetadata({ messageId: context.messageId }).error('Server tool execution failed', {
-      toolName,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Server tool execution failed',
-    }
-  }
-}
-
-async function executeSimWorkflowTool(
-  toolName: string,
-  params: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const handler = SIM_WORKFLOW_TOOL_HANDLERS[toolName]
-  if (!handler) return { success: false, error: `Unsupported workflow tool: ${toolName}` }
-
-  if (context.workflowId) {
-    if (toolName === 'create_workflow') {
-      return {
-        success: false,
-        error:
-          'Cannot create new workflows from the workflow copilot. You are scoped to the current workflow. Use the workspace chat to create new workflows.',
-      }
-    }
-
-    if (
-      toolName === 'edit_workflow' &&
-      params.workflowId &&
-      params.workflowId !== context.workflowId
-    ) {
-      return {
-        success: false,
-        error: `Cannot edit a different workflow. You are scoped to workflow ${context.workflowId}.`,
-      }
-    }
-  }
-
-  return handler(params, context)
-}
-
-/** Timeout for the mark-complete POST to the copilot backend (30 s). */
-const MARK_COMPLETE_TIMEOUT_MS = 30_000
-
-/**
- * Notify the copilot backend that a tool has completed.
- */
-export async function markToolComplete(
-  toolCallId: string,
-  toolName: string,
-  status: number,
-  message?: unknown,
-  data?: unknown,
-  messageId?: string
-): Promise<boolean> {
-  try {
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), MARK_COMPLETE_TIMEOUT_MS)
-
-    try {
-      const response = await fetch(`${SIM_AGENT_API_URL}/api/tools/mark-complete`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
-        },
-        body: JSON.stringify({
-          id: toolCallId,
-          name: toolName,
-          status,
-          message,
-          data,
-        }),
-        signal: controller.signal,
-      })
-
-      if (!response.ok) {
-        logger.withMetadata({ messageId }).warn('Mark-complete call failed', {
-          toolCallId,
-          toolName,
-          status: response.status,
-        })
-        return false
-      }
-
-      return true
-    } finally {
-      clearTimeout(timeoutId)
-    }
-  } catch (error) {
-    const isTimeout = error instanceof DOMException && error.name === 'AbortError'
-    logger.withMetadata({ messageId }).error('Mark-complete call failed', {
-      toolCallId,
-      toolName,
-      timedOut: isTimeout,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return false
-  }
-}
-
-/**
- * Prepare execution context with cached environment values.
- */
-export async function prepareExecutionContext(
-  userId: string,
-  workflowId: string,
-  chatId?: string
-): Promise<ExecutionContext> {
-  const wf = await getWorkflowById(workflowId)
-  const workspaceId = wf?.workspaceId ?? undefined
-
-  const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
-
-  return {
-    userId,
-    workflowId,
-    workspaceId,
-    chatId,
-    decryptedEnvVars,
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/integration-tools.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/integration-tools.ts
deleted file mode 100644
index 7e7d74f4d29..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/integration-tools.ts
+++ /dev/null
@@ -1,285 +0,0 @@
-import { db } from '@sim/db'
-import { account } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { eq } from 'drizzle-orm'
-import type {
-  ExecutionContext,
-  ToolCallResult,
-  ToolCallState,
-} from '@/lib/copilot/orchestrator/types'
-import { isHosted } from '@/lib/core/config/feature-flags'
-import { generateRequestId } from '@/lib/core/utils/request'
-import { getCredentialActorContext } from '@/lib/credentials/access'
-import { getAccessibleOAuthCredentials } from '@/lib/credentials/environment'
-import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { getServiceAccountProviderForProviderId } from '@/lib/oauth/utils'
-import { getTableById, queryRows } from '@/lib/table/service'
-import {
-  downloadWorkspaceFile,
-  findWorkspaceFileRecord,
-  getSandboxWorkspaceFilePath,
-  listWorkspaceFiles,
-} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
-import { getWorkflowById } from '@/lib/workflows/utils'
-import { refreshTokenIfNeeded } from '@/app/api/auth/oauth/utils'
-import { resolveEnvVarReferences } from '@/executor/utils/reference-validation'
-import { executeTool } from '@/tools'
-import type { ToolConfig } from '@/tools/types'
-import { resolveToolId } from '@/tools/utils'
-
-const logger = createLogger('CopilotIntegrationTools')
-
-function csvEscapeValue(value: unknown): string {
-  if (value === null || value === undefined) return ''
-  if (typeof value === 'number' || typeof value === 'boolean') return String(value)
-  const str = String(value)
-  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
-    return `"${str.replace(/"/g, '""')}"`
-  }
-  return str
-}
-
-export async function executeIntegrationToolDirect(
-  toolCall: ToolCallState,
-  toolConfig: ToolConfig,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const { userId, workflowId } = context
-  const toolName = resolveToolId(toolCall.name)
-  const toolArgs = toolCall.params || {}
-
-  let workspaceId = context.workspaceId
-  if (!workspaceId && workflowId) {
-    const wf = await getWorkflowById(workflowId)
-    workspaceId = wf?.workspaceId ?? undefined
-  }
-
-  const decryptedEnvVars =
-    context.decryptedEnvVars || (await getEffectiveDecryptedEnv(userId, workspaceId))
-
-  const executionParams = resolveEnvVarReferences(toolArgs, decryptedEnvVars, {
-    deep: true,
-  }) as Record<string, unknown>
-
-  // If the LLM passed a credential/oauthCredential ID directly, verify the user
-  // has active credential_member access before proceeding. This prevents
-  // unauthorized credential usage even if the agent hallucinated or received
-  // a credential ID the user doesn't have access to.
-  const suppliedCredentialId = (executionParams.credentialId ||
-    executionParams.oauthCredential ||
-    executionParams.credential) as string | undefined
-  if (suppliedCredentialId) {
-    const actorCtx = await getCredentialActorContext(suppliedCredentialId, userId)
-    if (!actorCtx.member) {
-      logger.warn('Blocked credential use: user lacks credential_member access', {
-        credentialId: suppliedCredentialId,
-        userId,
-        toolName,
-      })
-      return {
-        success: false,
-        error: `You do not have access to credential "${suppliedCredentialId}". Ask the credential admin to add you as a member, or connect your own account.`,
-      }
-    }
-  }
-
-  if (toolConfig.oauth?.required && toolConfig.oauth.provider) {
-    const provider = toolConfig.oauth.provider
-
-    // Determine which credential to use: supplied by the LLM or auto-resolved
-    let resolvedCredentialId = suppliedCredentialId
-
-    if (!resolvedCredentialId) {
-      if (!workspaceId) {
-        return {
-          success: false,
-          error: `Cannot resolve ${provider} credential without a workspace context.`,
-        }
-      }
-
-      const accessibleCreds = await getAccessibleOAuthCredentials(workspaceId, userId)
-      const saProviderId = getServiceAccountProviderForProviderId(provider)
-      const match =
-        accessibleCreds.find((c) => c.providerId === provider) ||
-        (saProviderId ? accessibleCreds.find((c) => c.providerId === saProviderId) : undefined)
-
-      if (!match) {
-        return {
-          success: false,
-          error: `No accessible ${provider} account found. You either don't have a ${provider} account connected in this workspace, or you don't have access to the existing one. Please connect your own account.`,
-        }
-      }
-
-      resolvedCredentialId = match.id
-    }
-
-    const matchCtx = await getCredentialActorContext(resolvedCredentialId, userId)
-
-    if (matchCtx.credential?.type === 'service_account') {
-      executionParams.oauthCredential = resolvedCredentialId
-    } else {
-      const accountId = matchCtx.credential?.accountId
-      if (!accountId) {
-        return {
-          success: false,
-          error: `OAuth account for ${provider} not found. Please reconnect your account.`,
-        }
-      }
-
-      const [acc] = await db.select().from(account).where(eq(account.id, accountId)).limit(1)
-
-      if (!acc) {
-        return {
-          success: false,
-          error: `OAuth account for ${provider} not found. Please reconnect your account.`,
-        }
-      }
-
-      const requestId = generateRequestId()
-      const { accessToken } = await refreshTokenIfNeeded(requestId, acc, acc.id)
-
-      if (!accessToken) {
-        return {
-          success: false,
-          error: `OAuth token not available for ${provider}. Please reconnect your account.`,
-        }
-      }
-
-      executionParams.accessToken = accessToken
-    }
-  }
-
-  const hasHostedKeySupport = isHosted && !!toolConfig.hosting
-  if (toolConfig.params?.apiKey?.required && !executionParams.apiKey && !hasHostedKeySupport) {
-    return {
-      success: false,
-      error: `API key not provided for ${toolName}. Use {{YOUR_API_KEY_ENV_VAR}} to reference your environment variable.`,
-    }
-  }
-
-  executionParams._context = {
-    workflowId,
-    workspaceId,
-    userId,
-    enforceCredentialAccess: true,
-  }
-
-  if (toolName === 'function_execute') {
-    executionParams.envVars = decryptedEnvVars
-    executionParams.workflowVariables = {}
-    executionParams.blockData = {}
-    executionParams.blockNameMapping = {}
-    executionParams.language = executionParams.language || 'javascript'
-    executionParams.timeout = executionParams.timeout || 30000
-
-    if (isHosted && workspaceId) {
-      const sandboxFiles: Array<{ path: string; content: string }> = []
-      const MAX_FILE_SIZE = 10 * 1024 * 1024
-      const MAX_TOTAL_SIZE = 50 * 1024 * 1024
-      const TEXT_EXTENSIONS = new Set([
-        'csv',
-        'json',
-        'txt',
-        'md',
-        'html',
-        'xml',
-        'tsv',
-        'yaml',
-        'yml',
-      ])
-      let totalSize = 0
-
-      const inputFileIds = executionParams.inputFiles as string[] | undefined
-      if (inputFileIds?.length) {
-        const allFiles = await listWorkspaceFiles(workspaceId)
-        for (const fileRef of inputFileIds) {
-          const record = findWorkspaceFileRecord(allFiles, fileRef)
-          if (!record) {
-            logger.warn('Sandbox input file not found', { fileRef })
-            continue
-          }
-          const ext = record.name.split('.').pop()?.toLowerCase() ?? ''
-          if (!TEXT_EXTENSIONS.has(ext)) {
-            logger.warn('Skipping non-text sandbox input file', {
-              fileId: record.id,
-              fileName: record.name,
-              ext,
-            })
-            continue
-          }
-          if (record.size > MAX_FILE_SIZE) {
-            logger.warn('Sandbox input file exceeds size limit', {
-              fileId: record.id,
-              fileName: record.name,
-              size: record.size,
-            })
-            continue
-          }
-          if (totalSize + record.size > MAX_TOTAL_SIZE) {
-            logger.warn('Sandbox input total size limit reached, skipping remaining files')
-            break
-          }
-          const buffer = await downloadWorkspaceFile(record)
-          totalSize += buffer.length
-          const textContent = buffer.toString('utf-8')
-          sandboxFiles.push({
-            path: getSandboxWorkspaceFilePath(record),
-            content: textContent,
-          })
-          sandboxFiles.push({
-            path: `/home/user/${record.name}`,
-            content: textContent,
-          })
-        }
-      }
-
-      const inputTableIds = executionParams.inputTables as string[] | undefined
-      if (inputTableIds?.length) {
-        for (const tableId of inputTableIds) {
-          const table = await getTableById(tableId)
-          if (!table) {
-            logger.warn('Sandbox input table not found', { tableId })
-            continue
-          }
-          const { rows } = await queryRows(tableId, workspaceId, { limit: 10000 }, 'sandbox-input')
-          const schema = table.schema as { columns: Array<{ name: string; type?: string }> }
-          const cols = schema.columns.map((c) => c.name)
-          const typeComment = `# types: ${schema.columns.map((c) => `${c.name}=${c.type || 'string'}`).join(', ')}`
-          const csvLines = [typeComment, cols.join(',')]
-          for (const row of rows) {
-            csvLines.push(
-              cols.map((c) => csvEscapeValue((row.data as Record<string, unknown>)[c])).join(',')
-            )
-          }
-          const csvContent = csvLines.join('\n')
-          if (totalSize + csvContent.length > MAX_TOTAL_SIZE) {
-            logger.warn('Sandbox input total size limit reached, skipping remaining tables')
-            break
-          }
-          totalSize += csvContent.length
-          sandboxFiles.push({ path: `/home/user/tables/${tableId}.csv`, content: csvContent })
-        }
-      }
-
-      if (sandboxFiles.length > 0) {
-        executionParams._sandboxFiles = sandboxFiles
-        logger.info('Prepared sandbox input files', {
-          fileCount: sandboxFiles.length,
-          totalSize,
-          paths: sandboxFiles.map((f) => f.path),
-        })
-      }
-
-      executionParams.inputFiles = undefined
-      executionParams.inputTables = undefined
-    }
-  }
-
-  const result = await executeTool(toolName, executionParams)
-
-  return {
-    success: result.success,
-    output: result.output,
-    error: result.error,
-  }
-}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/index.ts b/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/index.ts
deleted file mode 100644
index b908b07108d..00000000000
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './mutations'
-export * from './queries'
diff --git a/apps/sim/lib/copilot/persistence/tool-confirm/index.ts b/apps/sim/lib/copilot/persistence/tool-confirm/index.ts
new file mode 100644
index 00000000000..65f5df9884e
--- /dev/null
+++ b/apps/sim/lib/copilot/persistence/tool-confirm/index.ts
@@ -0,0 +1,169 @@
+import { createLogger } from '@sim/logger'
+import {
+  ASYNC_TOOL_STATUS,
+  type AsyncCompletionEnvelope,
+  type AsyncConfirmationState,
+  isAsyncEphemeralConfirmationStatus,
+} from '@/lib/copilot/async-runs/lifecycle'
+import { getAsyncToolCalls } from '@/lib/copilot/async-runs/repository'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import { getRedisClient } from '@/lib/core/config/redis'
+import { createPubSubChannel } from '@/lib/events/pubsub'
+
+const logger = createLogger('CopilotOrchestratorPersistence')
+const TOOL_CONFIRMATION_TTL_SECONDS = 60 * 10
+const toolConfirmationKey = (toolCallId: string) => `copilot:tool-confirmation:${toolCallId}`
+
+const toolConfirmationChannel = createPubSubChannel<AsyncCompletionEnvelope>({
+  channel: 'copilot:tool-confirmation',
+  label: 'CopilotToolConfirmation',
+})
+
+/**
+ * Get a tool call confirmation state from the durable async tool row.
+ *
+ * The durable row reconstructs only the live execution lifecycle plus the
+ * `background` detach signal.
+ */
+export async function getToolConfirmation(
+  toolCallId: string
+): Promise<AsyncConfirmationState | null> {
+  const [row] = await getAsyncToolCalls([toolCallId]).catch((err) => {
+    logger.warn('Failed to fetch async tool calls', {
+      toolCallId,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return []
+  })
+  if (!row) return null
+  if (row.status === ASYNC_TOOL_STATUS.delivered) {
+    logger.warn('Delivered async tool rows are outside request confirmation flow', {
+      toolCallId,
+    })
+    return null
+  }
+  return {
+    status:
+      row.status === ASYNC_TOOL_STATUS.completed
+        ? MothershipStreamV1ToolOutcome.success
+        : row.status === ASYNC_TOOL_STATUS.failed
+          ? MothershipStreamV1ToolOutcome.error
+          : row.status === ASYNC_TOOL_STATUS.cancelled
+            ? MothershipStreamV1ToolOutcome.cancelled
+            : row.status,
+    message: row.error || undefined,
+    ...(row.result !== undefined ? { data: row.result } : {}),
+    timestamp: row.updatedAt?.toISOString?.(),
+  }
+}
+
+export function publishToolConfirmation(event: AsyncCompletionEnvelope): void {
+  logger.info('Publishing tool confirmation event', {
+    toolCallId: event.toolCallId,
+    status: event.status,
+  })
+  const redis = getRedisClient()
+  if (redis) {
+    void redis
+      .set(
+        toolConfirmationKey(event.toolCallId),
+        JSON.stringify(event),
+        'EX',
+        TOOL_CONFIRMATION_TTL_SECONDS
+      )
+      .then(() => {
+        logger.info('Persisted tool confirmation in Redis', {
+          toolCallId: event.toolCallId,
+          status: event.status,
+          redisKey: toolConfirmationKey(event.toolCallId),
+        })
+      })
+      .catch((error) => {
+        logger.warn('Failed to persist tool confirmation in Redis', {
+          toolCallId: event.toolCallId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      })
+  } else {
+    logger.warn('Redis unavailable while publishing tool confirmation', {
+      toolCallId: event.toolCallId,
+      status: event.status,
+    })
+  }
+  toolConfirmationChannel.publish(event)
+}
+
+/**
+ * Wait for an async tool confirmation update.
+ *
+ * `background` still arrives as a request-local detach signal, so it is checked
+ * from pubsub before falling back to the durable async tool row.
+ */
+export async function waitForToolConfirmation(
+  toolCallId: string,
+  timeoutMs: number,
+  abortSignal?: AbortSignal,
+  options: {
+    acceptStatus?: (status: AsyncConfirmationState['status']) => boolean
+  } = {}
+): Promise<AsyncConfirmationState | null> {
+  const acceptStatus = options.acceptStatus ?? (() => true)
+  return new Promise((resolve) => {
+    let settled = false
+    let timeoutId: ReturnType<typeof setTimeout> | null = null
+    let unsubscribe: (() => void) | null = null
+
+    const cleanup = () => {
+      if (timeoutId) clearTimeout(timeoutId)
+      if (unsubscribe) unsubscribe()
+      abortSignal?.removeEventListener('abort', onAbort)
+    }
+
+    const settle = (value: AsyncConfirmationState | null) => {
+      if (settled) return
+      settled = true
+      cleanup()
+      resolve(value)
+    }
+
+    const onAbort = () => settle(null)
+
+    unsubscribe = toolConfirmationChannel.subscribe((event) => {
+      if (event.toolCallId !== toolCallId) return
+      if (isAsyncEphemeralConfirmationStatus(event.status) && acceptStatus(event.status)) {
+        settle({
+          status: event.status,
+          ...(event.message !== undefined ? { message: event.message } : {}),
+          ...(event.data !== undefined ? { data: event.data } : {}),
+          ...(event.timestamp !== undefined ? { timestamp: event.timestamp } : {}),
+        })
+        return
+      }
+      void getToolConfirmation(toolCallId).then((latest) => {
+        if (!latest || !acceptStatus(latest.status)) return
+        logger.info('Resolved tool confirmation from pubsub', {
+          toolCallId,
+          status: latest.status,
+        })
+        settle(latest)
+      })
+    })
+
+    timeoutId = setTimeout(() => settle(null), timeoutMs)
+    if (abortSignal?.aborted) {
+      settle(null)
+      return
+    }
+    abortSignal?.addEventListener('abort', onAbort, { once: true })
+
+    void getToolConfirmation(toolCallId).then((latest) => {
+      if (latest && acceptStatus(latest.status)) {
+        logger.info('Resolved tool confirmation after subscribe', {
+          toolCallId,
+          status: latest.status,
+        })
+        settle(latest)
+      }
+    })
+  })
+}
diff --git a/apps/sim/lib/copilot/orchestrator/persistence.test.ts b/apps/sim/lib/copilot/persistence/tool-confirm/tool-confirm.test.ts
similarity index 57%
rename from apps/sim/lib/copilot/orchestrator/persistence.test.ts
rename to apps/sim/lib/copilot/persistence/tool-confirm/tool-confirm.test.ts
index 0474fab9f80..efe38c759ab 100644
--- a/apps/sim/lib/copilot/orchestrator/persistence.test.ts
+++ b/apps/sim/lib/copilot/persistence/tool-confirm/tool-confirm.test.ts
@@ -33,13 +33,13 @@ import {
   getToolConfirmation,
   publishToolConfirmation,
   waitForToolConfirmation,
-} from './persistence'
+} from '@/lib/copilot/persistence/tool-confirm'
 
 describe('copilot orchestrator persistence', () => {
   let row: {
     status: string
     error?: string | null
-    result?: Record<string, unknown> | null
+    result?: unknown
     updatedAt: Date
   } | null
 
@@ -66,7 +66,34 @@ describe('copilot orchestrator persistence', () => {
     })
   })
 
-  it('waits through intermediate events until the durable row becomes terminal', async () => {
+  it('preserves primitive durable results in confirmations', async () => {
+    row = {
+      status: 'completed',
+      result: 'done',
+      error: null,
+      updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    }
+
+    await expect(getToolConfirmation('tool-1')).resolves.toEqual({
+      status: 'success',
+      message: undefined,
+      data: 'done',
+      timestamp: '2026-01-01T00:00:00.000Z',
+    })
+  })
+
+  it('ignores delivered rows in request confirmation flow', async () => {
+    row = {
+      status: 'delivered',
+      result: { ok: true },
+      error: null,
+      updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    }
+
+    await expect(getToolConfirmation('tool-1')).resolves.toBeNull()
+  })
+
+  it('ignores background when waiting for a foreground terminal status', async () => {
     row = {
       status: 'pending',
       error: null,
@@ -81,7 +108,8 @@ describe('copilot orchestrator persistence', () => {
 
     publishToolConfirmation({
       toolCallId: 'tool-1',
-      status: 'accepted',
+      status: 'background',
+      message: 'Client disconnected, execution continuing server-side',
       timestamp: '2026-01-01T00:00:01.000Z',
     })
 
@@ -107,4 +135,32 @@ describe('copilot orchestrator persistence', () => {
       timestamp: '2026-01-01T00:00:02.000Z',
     })
   })
+
+  it('resolves background from the pubsub event when the durable row stays pending', async () => {
+    row = {
+      status: 'pending',
+      error: null,
+      result: null,
+      updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    }
+
+    const waitPromise = waitForToolConfirmation('tool-1', 5_000, undefined, {
+      acceptStatus: (status) => status === 'background',
+    })
+
+    await Promise.resolve()
+
+    publishToolConfirmation({
+      toolCallId: 'tool-1',
+      status: 'background',
+      message: 'Client disconnected, execution continuing server-side',
+      timestamp: '2026-01-01T00:00:01.000Z',
+    })
+
+    await expect(waitPromise).resolves.toEqual({
+      status: 'background',
+      message: 'Client disconnected, execution continuing server-side',
+      timestamp: '2026-01-01T00:00:01.000Z',
+    })
+  })
 })
diff --git a/apps/sim/lib/copilot/request/context/request-context.ts b/apps/sim/lib/copilot/request/context/request-context.ts
new file mode 100644
index 00000000000..bed52c21a49
--- /dev/null
+++ b/apps/sim/lib/copilot/request/context/request-context.ts
@@ -0,0 +1,33 @@
+import { TraceCollector } from '@/lib/copilot/request/trace'
+import type { StreamingContext } from '@/lib/copilot/request/types'
+import { generateId } from '@/lib/core/utils/uuid'
+
+/**
+ * Create a fresh StreamingContext.
+ */
+export function createStreamingContext(overrides?: Partial<StreamingContext>): StreamingContext {
+  return {
+    chatId: undefined,
+    executionId: undefined,
+    runId: undefined,
+    messageId: generateId(),
+    accumulatedContent: '',
+    contentBlocks: [],
+    toolCalls: new Map(),
+    pendingToolPromises: new Map(),
+    currentThinkingBlock: null,
+    currentSubagentThinkingBlock: null,
+    isInThinkingBlock: false,
+    subAgentParentToolCallId: undefined,
+    subAgentParentStack: [],
+    subAgentContent: {},
+    subAgentToolCalls: {},
+    pendingContent: '',
+    streamComplete: false,
+    wasAborted: false,
+    errors: [],
+    activeFileIntent: null,
+    trace: new TraceCollector(),
+    ...overrides,
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/stream/core.test.ts b/apps/sim/lib/copilot/request/context/result.test.ts
similarity index 55%
rename from apps/sim/lib/copilot/orchestrator/stream/core.test.ts
rename to apps/sim/lib/copilot/request/context/result.test.ts
index 97e614caf6b..d570954e9e9 100644
--- a/apps/sim/lib/copilot/orchestrator/stream/core.test.ts
+++ b/apps/sim/lib/copilot/request/context/result.test.ts
@@ -2,8 +2,11 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { buildToolCallSummaries } from '@/lib/copilot/orchestrator/stream/core'
-import type { StreamingContext } from '@/lib/copilot/orchestrator/types'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import { FunctionExecute } from '@/lib/copilot/generated/tool-catalog-v1'
+import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
+import { TraceCollector } from '@/lib/copilot/request/trace'
+import type { StreamingContext } from '@/lib/copilot/request/types'
 
 function makeContext(): StreamingContext {
   return {
@@ -27,6 +30,7 @@ function makeContext(): StreamingContext {
     streamComplete: false,
     wasAborted: false,
     errors: [],
+    trace: new TraceCollector(),
   }
 }
 
@@ -50,7 +54,7 @@ describe('buildToolCallSummaries', () => {
     const context = makeContext()
     context.toolCalls.set('tool-2', {
       id: 'tool-2',
-      name: 'function_execute',
+      name: FunctionExecute.id,
       status: 'executing',
       startTime: 1,
     })
@@ -60,4 +64,33 @@ describe('buildToolCallSummaries', () => {
     expect(summaries).toHaveLength(1)
     expect(summaries[0]?.status).toBe('executing')
   })
+
+  it.concurrent(
+    'preserves canonical terminal statuses instead of deriving them from result success',
+    () => {
+      const context = makeContext()
+      context.toolCalls.set('tool-3', {
+        id: 'tool-3',
+        name: 'download_to_workspace_file',
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        result: { success: false },
+        error: 'Stopped by user',
+        startTime: 1,
+        endTime: 2,
+      })
+
+      const summaries = buildToolCallSummaries(context)
+
+      expect(summaries).toHaveLength(1)
+      expect(summaries[0]).toEqual({
+        id: 'tool-3',
+        name: 'download_to_workspace_file',
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        params: undefined,
+        result: undefined,
+        error: 'Stopped by user',
+        durationMs: 1,
+      })
+    }
+  )
 })
diff --git a/apps/sim/lib/copilot/request/context/result.ts b/apps/sim/lib/copilot/request/context/result.ts
new file mode 100644
index 00000000000..19eaf9cb6bf
--- /dev/null
+++ b/apps/sim/lib/copilot/request/context/result.ts
@@ -0,0 +1,18 @@
+import { getToolCallStateOutput } from '@/lib/copilot/request/tool-call-state'
+import type { StreamingContext, ToolCallSummary } from '@/lib/copilot/request/types'
+
+/**
+ * Build a ToolCallSummary array from the streaming context.
+ */
+export function buildToolCallSummaries(context: StreamingContext): ToolCallSummary[] {
+  return Array.from(context.toolCalls.values()).map((toolCall) => ({
+    id: toolCall.id,
+    name: toolCall.name,
+    status: toolCall.status,
+    params: toolCall.params,
+    result: getToolCallStateOutput(toolCall),
+    error: toolCall.error,
+    durationMs:
+      toolCall.endTime && toolCall.startTime ? toolCall.endTime - toolCall.startTime : undefined,
+  }))
+}
diff --git a/apps/sim/lib/copilot/request/go/file-preview-adapter.ts b/apps/sim/lib/copilot/request/go/file-preview-adapter.ts
new file mode 100644
index 00000000000..b5f66051319
--- /dev/null
+++ b/apps/sim/lib/copilot/request/go/file-preview-adapter.ts
@@ -0,0 +1,633 @@
+import { createLogger } from '@sim/logger'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  createFilePreviewSession,
+  type FilePreviewContentMode,
+  type FilePreviewSession,
+  type FilePreviewTargetKind,
+  isToolArgsDeltaStreamEvent,
+  isToolCallStreamEvent,
+  isToolResultStreamEvent,
+  type SyntheticFilePreviewPayload,
+  upsertFilePreviewSession,
+} from '@/lib/copilot/request/session'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+import {
+  clearIntentsForWorkspace,
+  peekFileIntent,
+} from '@/lib/copilot/tools/server/files/file-intent-store'
+import {
+  buildFilePreviewText,
+  loadWorkspaceFileTextForPreview,
+} from '@/lib/copilot/tools/server/files/file-preview'
+
+const logger = createLogger('CopilotFilePreviewAdapter')
+
+type JsonRecord = Record<string, unknown>
+type FileIntent = NonNullable<StreamingContext['activeFileIntent']>
+
+type EditContentStreamState = {
+  raw: string
+  lastContentSnapshot?: string
+}
+
+type FilePreviewStreamState = {
+  session: FilePreviewSession
+  lastEmittedPreviewText: string
+  lastSnapshotAt: number
+}
+
+type ParsedWorkspaceFileArgs = {
+  operation: string
+  target: FileIntent['target']
+  title?: string
+  contentType?: string
+  edit?: JsonRecord
+}
+
+const PATCH_PREVIEW_SNAPSHOT_INTERVAL_MS = 80
+const DELTA_PREVIEW_CHECKPOINT_INTERVAL_MS = 1000
+
+function asJsonRecord(value: unknown): JsonRecord | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as JsonRecord)
+    : undefined
+}
+
+function toPreviewTargetKind(kind: string | undefined): FilePreviewTargetKind | undefined {
+  return kind === 'new_file' || kind === 'file_id' ? kind : undefined
+}
+
+function parseWorkspaceFileArgs(value: unknown): ParsedWorkspaceFileArgs | undefined {
+  const args = asJsonRecord(value)
+  if (!args) {
+    return undefined
+  }
+
+  const operation = typeof args.operation === 'string' ? args.operation : undefined
+  const target = asJsonRecord(args.target)
+  const targetKind = typeof target?.kind === 'string' ? target.kind : undefined
+  if (!operation || !target || !targetKind) {
+    return undefined
+  }
+
+  const fileId = typeof target.fileId === 'string' ? target.fileId : undefined
+  const fileName = typeof target.fileName === 'string' ? target.fileName : undefined
+  const title = typeof args.title === 'string' ? args.title : undefined
+  const contentType = typeof args.contentType === 'string' ? args.contentType : undefined
+  const edit = asJsonRecord(args.edit)
+
+  return {
+    operation,
+    target: {
+      kind: targetKind,
+      ...(fileId ? { fileId } : {}),
+      ...(fileName ? { fileName } : {}),
+    },
+    ...(title ? { title } : {}),
+    ...(contentType ? { contentType } : {}),
+    ...(edit ? { edit } : {}),
+  }
+}
+
+export function decodeJsonStringPrefix(input: string): string {
+  let output = ''
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i]
+    if (ch !== '\\') {
+      output += ch
+      continue
+    }
+    const next = input[i + 1]
+    if (!next) break
+    if (next === 'n') {
+      output += '\n'
+      i++
+      continue
+    }
+    if (next === 't') {
+      output += '\t'
+      i++
+      continue
+    }
+    if (next === 'r') {
+      output += '\r'
+      i++
+      continue
+    }
+    if (next === '"') {
+      output += '"'
+      i++
+      continue
+    }
+    if (next === '\\') {
+      output += '\\'
+      i++
+      continue
+    }
+    if (next === '/') {
+      output += '/'
+      i++
+      continue
+    }
+    if (next === 'b') {
+      output += '\b'
+      i++
+      continue
+    }
+    if (next === 'f') {
+      output += '\f'
+      i++
+      continue
+    }
+    if (next === 'u') {
+      const hex = input.slice(i + 2, i + 6)
+      if (hex.length < 4 || !/^[0-9a-fA-F]{4}$/.test(hex)) break
+      output += String.fromCharCode(Number.parseInt(hex, 16))
+      i += 5
+      continue
+    }
+    break
+  }
+  return output
+}
+
+export function extractEditContent(raw: string): string {
+  const marker = '"content":'
+  const idx = raw.indexOf(marker)
+  if (idx === -1) return ''
+  const rest = raw.slice(idx + marker.length).trimStart()
+  if (!rest.startsWith('"')) return rest
+  let end = -1
+  for (let i = 1; i < rest.length; i++) {
+    if (rest[i] === '\\') {
+      i++
+      continue
+    }
+    if (rest[i] === '"') {
+      end = i
+      break
+    }
+  }
+  const inner = end === -1 ? rest.slice(1) : rest.slice(1, end)
+  return decodeJsonStringPrefix(inner)
+}
+
+function isContentOperation(
+  operation: string | undefined
+): operation is 'append' | 'update' | 'patch' {
+  return operation === 'append' || operation === 'update' || operation === 'patch'
+}
+
+function isDocFormat(fileName: string | undefined): boolean {
+  return /\.(pptx|docx|pdf)$/i.test(fileName ?? '')
+}
+
+function buildPreviewSessionFromIntent(
+  streamId: string,
+  intent: FileIntent,
+  current?: FilePreviewSession
+): FilePreviewSession {
+  const targetKind = toPreviewTargetKind(intent.target.kind)
+
+  return createFilePreviewSession({
+    streamId,
+    toolCallId: intent.toolCallId,
+    fileName: intent.target.fileName ?? current?.fileName,
+    ...(intent.target.fileId ? { fileId: intent.target.fileId } : {}),
+    ...(targetKind ? { targetKind } : {}),
+    operation: intent.operation,
+    ...(intent.edit ? { edit: intent.edit } : {}),
+    ...(typeof current?.baseContent === 'string' ? { baseContent: current.baseContent } : {}),
+    previewText: current?.previewText ?? '',
+    previewVersion: current?.previewVersion ?? 0,
+    status: current?.status ?? 'pending',
+    completedAt: current?.completedAt,
+  })
+}
+
+async function persistFilePreviewSession(session: FilePreviewSession): Promise<void> {
+  try {
+    await upsertFilePreviewSession(session)
+  } catch (error) {
+    logger.warn('Failed to persist file preview session', {
+      streamId: session.streamId,
+      toolCallId: session.toolCallId,
+      previewVersion: session.previewVersion,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+export function buildPreviewContentUpdate(
+  previousText: string,
+  nextText: string,
+  lastSnapshotAt: number,
+  now: number,
+  operation: string | undefined
+): { content: string; contentMode: FilePreviewContentMode; lastSnapshotAt: number } {
+  const shouldForceSnapshot =
+    previousText.length === 0 ||
+    !nextText.startsWith(previousText) ||
+    operation === 'patch' ||
+    operation === 'append' ||
+    now - lastSnapshotAt >= DELTA_PREVIEW_CHECKPOINT_INTERVAL_MS
+
+  if (shouldForceSnapshot) {
+    return {
+      content: nextText,
+      contentMode: 'snapshot',
+      lastSnapshotAt: now,
+    }
+  }
+
+  return {
+    content: nextText.slice(previousText.length),
+    contentMode: 'delta',
+    lastSnapshotAt,
+  }
+}
+
+export interface FilePreviewAdapterState {
+  editContentState: Map<string, EditContentStreamState>
+  filePreviewState: Map<string, FilePreviewStreamState>
+}
+
+export function createFilePreviewAdapterState(): FilePreviewAdapterState {
+  return {
+    editContentState: new Map<string, EditContentStreamState>(),
+    filePreviewState: new Map<string, FilePreviewStreamState>(),
+  }
+}
+
+async function emitPreviewEvent(
+  streamEvent: StreamEvent,
+  options: Pick<OrchestratorOptions, 'onEvent'>,
+  payload: SyntheticFilePreviewPayload
+): Promise<void> {
+  await options.onEvent?.({
+    type: MothershipStreamV1EventType.tool,
+    payload,
+    ...(streamEvent.scope ? { scope: streamEvent.scope } : {}),
+  })
+}
+
+export async function processFilePreviewStreamEvent(input: {
+  streamId: string
+  streamEvent: StreamEvent
+  context: StreamingContext
+  execContext: ExecutionContext
+  options: Pick<OrchestratorOptions, 'onEvent'>
+  state: FilePreviewAdapterState
+}): Promise<void> {
+  const { streamId, streamEvent, context, execContext, options, state } = input
+  const { editContentState, filePreviewState } = state
+
+  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'workspace_file') {
+    const toolCallId = streamEvent.payload.toolCallId
+    const parsedArgs = parseWorkspaceFileArgs(streamEvent.payload.arguments)
+    if (toolCallId && parsedArgs) {
+      const { operation, target, title, contentType, edit } = parsedArgs
+      const previewTargetKind = toPreviewTargetKind(target.kind)
+      const { fileId, fileName } = target
+
+      const isContentOp = isContentOperation(operation)
+      if (context.activeFileIntent && isContentOp) {
+        logger.warn(
+          'Orphaned workspace_file intent: content-op workspace_file arrived without edit_content for prior intent',
+          {
+            orphanedToolCallId: context.activeFileIntent.toolCallId,
+            orphanedOperation: context.activeFileIntent.operation,
+            newToolCallId: toolCallId,
+            newOperation: operation,
+          }
+        )
+        if (execContext.workspaceId) {
+          const cleared = await clearIntentsForWorkspace(execContext.workspaceId, {
+            chatId: execContext.chatId,
+            messageId: execContext.messageId,
+          })
+          if (cleared > 0) {
+            logger.warn('Cleared orphaned execution intents from store', {
+              cleared,
+              workspaceId: execContext.workspaceId,
+            })
+          }
+        }
+      }
+
+      context.activeFileIntent = {
+        toolCallId,
+        operation,
+        target,
+        ...(title ? { title } : {}),
+        ...(contentType ? { contentType } : {}),
+        ...(edit ? { edit } : {}),
+      }
+
+      if (!isDocFormat(fileName) && isContentOp && previewTargetKind) {
+        let previewBaseContent: string | undefined
+        if (
+          execContext.workspaceId &&
+          fileId &&
+          (operation === 'append' || operation === 'patch')
+        ) {
+          previewBaseContent = await loadWorkspaceFileTextForPreview(
+            execContext.workspaceId,
+            fileId
+          )
+        }
+
+        let session = buildPreviewSessionFromIntent(streamId, context.activeFileIntent)
+        if (previewBaseContent !== undefined) {
+          session = { ...session, baseContent: previewBaseContent }
+        }
+        filePreviewState.set(toolCallId, {
+          session,
+          lastEmittedPreviewText: '',
+          lastSnapshotAt: 0,
+        })
+        await persistFilePreviewSession(session)
+
+        await emitPreviewEvent(streamEvent, options, {
+          toolCallId,
+          toolName: 'workspace_file',
+          previewPhase: 'file_preview_start',
+        })
+        await emitPreviewEvent(streamEvent, options, {
+          toolCallId,
+          toolName: 'workspace_file',
+          previewPhase: 'file_preview_target',
+          operation,
+          target: {
+            kind: previewTargetKind,
+            ...(fileId ? { fileId } : {}),
+            ...(fileName ? { fileName } : {}),
+          },
+          ...(title ? { title } : {}),
+        })
+        if (edit) {
+          await emitPreviewEvent(streamEvent, options, {
+            toolCallId,
+            toolName: 'workspace_file',
+            previewPhase: 'file_preview_edit_meta',
+            edit,
+          })
+        }
+      }
+    }
+  }
+
+  if (
+    isToolResultStreamEvent(streamEvent) &&
+    streamEvent.payload.toolName === 'workspace_file' &&
+    context.activeFileIntent &&
+    isContentOperation(context.activeFileIntent.operation) &&
+    context.activeFileIntent.operation === 'patch' &&
+    context.activeFileIntent.edit?.strategy === 'anchored' &&
+    context.activeFileIntent.edit?.mode === 'delete_between' &&
+    execContext.workspaceId &&
+    context.activeFileIntent.target.fileId &&
+    !isDocFormat(context.activeFileIntent.target.fileName)
+  ) {
+    const currentPreview = filePreviewState.get(context.activeFileIntent.toolCallId)
+    const previewText = buildFilePreviewText({
+      operation: 'patch',
+      streamedContent: '',
+      existingContent: currentPreview?.session.baseContent,
+      edit: currentPreview?.session.edit,
+    })
+
+    if (previewText !== undefined) {
+      const baseSession = buildPreviewSessionFromIntent(
+        streamId,
+        context.activeFileIntent,
+        currentPreview?.session
+      )
+      const nextSession: FilePreviewSession = {
+        ...baseSession,
+        status: 'streaming',
+        previewText,
+        previewVersion: (currentPreview?.session.previewVersion ?? 0) + 1,
+        updatedAt: new Date().toISOString(),
+      }
+      filePreviewState.set(context.activeFileIntent.toolCallId, {
+        session: nextSession,
+        lastEmittedPreviewText: previewText,
+        lastSnapshotAt: Date.now(),
+      })
+      await persistFilePreviewSession(nextSession)
+      await emitPreviewEvent(streamEvent, options, {
+        toolCallId: nextSession.toolCallId,
+        toolName: 'workspace_file',
+        previewPhase: 'file_preview_content',
+        content: previewText,
+        contentMode: 'snapshot',
+        previewVersion: nextSession.previewVersion,
+        fileName: nextSession.fileName,
+        ...(nextSession.fileId ? { fileId: nextSession.fileId } : {}),
+        ...(nextSession.targetKind ? { targetKind: nextSession.targetKind } : {}),
+        ...(nextSession.operation ? { operation: nextSession.operation } : {}),
+        ...(nextSession.edit ? { edit: nextSession.edit } : {}),
+      })
+    }
+  }
+
+  if (isToolArgsDeltaStreamEvent(streamEvent) && streamEvent.payload.toolName === 'edit_content') {
+    const toolCallId = streamEvent.payload.toolCallId
+    const delta = streamEvent.payload.argumentsDelta
+    const stateForTool = editContentState.get(toolCallId) ?? { raw: '' }
+    stateForTool.raw += delta
+
+    if (context.activeFileIntent && !isDocFormat(context.activeFileIntent.target.fileName)) {
+      const streamedContent = extractEditContent(stateForTool.raw)
+      if (streamedContent !== (stateForTool.lastContentSnapshot ?? '')) {
+        stateForTool.lastContentSnapshot = streamedContent
+        let currentPreview = filePreviewState.get(context.activeFileIntent.toolCallId) ?? {
+          session: buildPreviewSessionFromIntent(streamId, context.activeFileIntent),
+          lastEmittedPreviewText: '',
+          lastSnapshotAt: 0,
+        }
+
+        if (
+          currentPreview.session.baseContent === undefined &&
+          (context.activeFileIntent.operation === 'append' ||
+            context.activeFileIntent.operation === 'patch') &&
+          execContext.workspaceId &&
+          context.activeFileIntent.target.fileId
+        ) {
+          const intentBase = await peekFileIntent(
+            execContext.workspaceId,
+            context.activeFileIntent.target.fileId,
+            {
+              chatId: execContext.chatId,
+              messageId: execContext.messageId,
+            }
+          )
+          if (typeof intentBase?.existingContent === 'string') {
+            const seededSession: FilePreviewSession = {
+              ...currentPreview.session,
+              baseContent: intentBase.existingContent,
+              ...(intentBase.edit ? { edit: intentBase.edit } : {}),
+            }
+            currentPreview = {
+              ...currentPreview,
+              session: seededSession,
+            }
+            filePreviewState.set(context.activeFileIntent.toolCallId, currentPreview)
+            await persistFilePreviewSession(seededSession)
+          }
+        }
+
+        const previewText = isContentOperation(context.activeFileIntent.operation)
+          ? buildFilePreviewText({
+              operation: context.activeFileIntent.operation,
+              streamedContent,
+              existingContent: currentPreview.session.baseContent,
+              edit: currentPreview.session.edit,
+            })
+          : undefined
+
+        if (previewText !== undefined) {
+          const baseSession = buildPreviewSessionFromIntent(
+            streamId,
+            context.activeFileIntent,
+            currentPreview.session
+          )
+          const now = Date.now()
+          const nextSession: FilePreviewSession = {
+            ...baseSession,
+            status: 'streaming',
+            previewText,
+            previewVersion: (currentPreview.session.previewVersion ?? 0) + 1,
+            updatedAt: new Date(now).toISOString(),
+          }
+
+          await persistFilePreviewSession(nextSession)
+
+          if (
+            nextSession.operation === 'patch' &&
+            now - currentPreview.lastSnapshotAt < PATCH_PREVIEW_SNAPSHOT_INTERVAL_MS
+          ) {
+            filePreviewState.set(context.activeFileIntent.toolCallId, {
+              session: nextSession,
+              lastEmittedPreviewText: currentPreview.lastEmittedPreviewText,
+              lastSnapshotAt: currentPreview.lastSnapshotAt,
+            })
+          } else {
+            const previewUpdate = buildPreviewContentUpdate(
+              currentPreview.lastEmittedPreviewText,
+              nextSession.previewText,
+              currentPreview.lastSnapshotAt,
+              now,
+              nextSession.operation
+            )
+
+            filePreviewState.set(context.activeFileIntent.toolCallId, {
+              session: nextSession,
+              lastEmittedPreviewText: nextSession.previewText,
+              lastSnapshotAt: previewUpdate.lastSnapshotAt,
+            })
+
+            await emitPreviewEvent(streamEvent, options, {
+              toolCallId: nextSession.toolCallId,
+              toolName: 'workspace_file',
+              previewPhase: 'file_preview_content',
+              content: previewUpdate.content,
+              contentMode: previewUpdate.contentMode,
+              previewVersion: nextSession.previewVersion,
+              fileName: nextSession.fileName,
+              ...(nextSession.fileId ? { fileId: nextSession.fileId } : {}),
+              ...(nextSession.targetKind ? { targetKind: nextSession.targetKind } : {}),
+              ...(nextSession.operation ? { operation: nextSession.operation } : {}),
+              ...(nextSession.edit ? { edit: nextSession.edit } : {}),
+            })
+          }
+        } else {
+          filePreviewState.set(context.activeFileIntent.toolCallId, {
+            session: currentPreview.session,
+            lastEmittedPreviewText: currentPreview.lastEmittedPreviewText,
+            lastSnapshotAt: currentPreview.lastSnapshotAt,
+          })
+        }
+      }
+    }
+
+    editContentState.set(toolCallId, stateForTool)
+  }
+
+  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'edit_content') {
+    const toolCallId = streamEvent.payload.toolCallId
+    if (toolCallId) {
+      editContentState.delete(toolCallId)
+    }
+  }
+
+  if (
+    isToolResultStreamEvent(streamEvent) &&
+    streamEvent.payload.toolName === 'edit_content' &&
+    context.activeFileIntent
+  ) {
+    const currentPreview = filePreviewState.get(context.activeFileIntent.toolCallId)
+    const completedAt = new Date().toISOString()
+
+    if (
+      currentPreview &&
+      currentPreview.lastEmittedPreviewText !== currentPreview.session.previewText &&
+      currentPreview.session.previewText.length > 0
+    ) {
+      filePreviewState.set(context.activeFileIntent.toolCallId, {
+        session: currentPreview.session,
+        lastEmittedPreviewText: currentPreview.session.previewText,
+        lastSnapshotAt: Date.now(),
+      })
+      await emitPreviewEvent(streamEvent, options, {
+        toolCallId: currentPreview.session.toolCallId,
+        toolName: 'workspace_file',
+        previewPhase: 'file_preview_content',
+        content: currentPreview.session.previewText,
+        contentMode: 'snapshot',
+        previewVersion: currentPreview.session.previewVersion,
+        fileName: currentPreview.session.fileName,
+        ...(currentPreview.session.fileId ? { fileId: currentPreview.session.fileId } : {}),
+        ...(currentPreview.session.targetKind
+          ? { targetKind: currentPreview.session.targetKind }
+          : {}),
+        ...(currentPreview.session.operation
+          ? { operation: currentPreview.session.operation }
+          : {}),
+        ...(currentPreview.session.edit ? { edit: currentPreview.session.edit } : {}),
+      })
+    }
+
+    if (currentPreview) {
+      const completedSession: FilePreviewSession = {
+        ...currentPreview.session,
+        status: 'complete',
+        updatedAt: completedAt,
+        completedAt,
+      }
+      filePreviewState.set(context.activeFileIntent.toolCallId, {
+        session: completedSession,
+        lastEmittedPreviewText: completedSession.previewText,
+        lastSnapshotAt: Date.now(),
+      })
+      await persistFilePreviewSession(completedSession)
+    }
+
+    await emitPreviewEvent(streamEvent, options, {
+      toolCallId: context.activeFileIntent.toolCallId,
+      toolName: 'workspace_file',
+      previewPhase: 'file_preview_complete',
+      fileId: context.activeFileIntent.target.fileId,
+      output: streamEvent.payload.output,
+      ...(currentPreview ? { previewVersion: currentPreview.session.previewVersion } : {}),
+    })
+    context.activeFileIntent = null
+  }
+}
diff --git a/apps/sim/lib/copilot/request/go/parser.ts b/apps/sim/lib/copilot/request/go/parser.ts
new file mode 100644
index 00000000000..7a4168fd08d
--- /dev/null
+++ b/apps/sim/lib/copilot/request/go/parser.ts
@@ -0,0 +1,128 @@
+import { createLogger } from '@sim/logger'
+
+const logger = createLogger('CopilotSseParser')
+
+export class FatalSseEventError extends Error {}
+
+function createParseFailure(message: string, preview: string): FatalSseEventError {
+  logger.error(message, { preview })
+  return new FatalSseEventError(message)
+}
+
+function normalizeSseLine(line: string): string {
+  return line.endsWith('\r') ? line.slice(0, -1) : line
+}
+
+/**
+ * Processes an SSE stream by calling onEvent for each parsed event.
+ *
+ * @param onEvent Called per parsed event. Return true to stop processing.
+ */
+export async function processSSEStream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  decoder: TextDecoder,
+  abortSignal: AbortSignal | undefined,
+  onEvent: (event: unknown) => boolean | undefined | Promise<boolean | undefined>
+): Promise<void> {
+  let buffer = ''
+
+  try {
+    try {
+      while (true) {
+        if (abortSignal?.aborted) {
+          logger.info('SSE stream aborted by signal')
+          break
+        }
+
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        let stopped = false
+        for (const line of lines) {
+          const normalizedLine = normalizeSseLine(line)
+          if (abortSignal?.aborted) {
+            logger.info('SSE stream aborted mid-chunk (between events)')
+            return
+          }
+          if (!normalizedLine.trim()) continue
+          if (!normalizedLine.startsWith('data: ')) continue
+
+          const jsonStr = normalizedLine.slice(6)
+          if (jsonStr === '[DONE]') continue
+
+          let parsed: unknown
+          try {
+            parsed = JSON.parse(jsonStr)
+          } catch (error) {
+            const preview = jsonStr.slice(0, 200)
+            const detail = error instanceof Error ? error.message : String(error)
+            throw createParseFailure(`Failed to parse SSE event JSON: ${detail}`, preview)
+          }
+
+          try {
+            if (await onEvent(parsed)) {
+              stopped = true
+              break
+            }
+          } catch (error) {
+            if (error instanceof FatalSseEventError) {
+              throw error
+            }
+            logger.warn('Failed to handle SSE event', {
+              preview: jsonStr.slice(0, 200),
+              error: error instanceof Error ? error.message : String(error),
+            })
+          }
+        }
+        if (stopped) break
+      }
+    } catch (error) {
+      const aborted =
+        abortSignal?.aborted || (error instanceof DOMException && error.name === 'AbortError')
+      if (aborted) {
+        logger.info('SSE stream read aborted')
+        return
+      }
+      throw error
+    }
+
+    const normalizedBuffer = normalizeSseLine(buffer)
+    if (normalizedBuffer.trim() && normalizedBuffer.startsWith('data: ')) {
+      const jsonStr = normalizedBuffer.slice(6)
+      if (jsonStr === '[DONE]') {
+        return
+      }
+
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(jsonStr)
+      } catch (error) {
+        const preview = normalizedBuffer.slice(0, 200)
+        const detail = error instanceof Error ? error.message : String(error)
+        throw createParseFailure(`Failed to parse final SSE buffer JSON: ${detail}`, preview)
+      }
+
+      try {
+        await onEvent(parsed)
+      } catch (error) {
+        if (error instanceof FatalSseEventError) {
+          throw error
+        }
+        logger.warn('Failed to handle final SSE event', {
+          preview: normalizedBuffer.slice(0, 200),
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock()
+    } catch {
+      logger.warn('Failed to release SSE reader lock')
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/go/stream.test.ts b/apps/sim/lib/copilot/request/go/stream.test.ts
new file mode 100644
index 00000000000..64349636b51
--- /dev/null
+++ b/apps/sim/lib/copilot/request/go/stream.test.ts
@@ -0,0 +1,284 @@
+/**
+ * @vitest-environment node
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1ToolExecutor,
+  MothershipStreamV1ToolMode,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  buildPreviewContentUpdate,
+  decodeJsonStringPrefix,
+  extractEditContent,
+  runStreamLoop,
+} from '@/lib/copilot/request/go/stream'
+import { createEvent } from '@/lib/copilot/request/session'
+import { TraceCollector } from '@/lib/copilot/request/trace'
+import type { ExecutionContext, StreamingContext } from '@/lib/copilot/request/types'
+
+function createSseResponse(events: unknown[]): Response {
+  const payload = events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join('')
+
+  return new Response(
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(payload))
+        controller.close()
+      },
+    }),
+    {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+      },
+    }
+  )
+}
+
+function createRawSseResponse(payload: string): Response {
+  return new Response(
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(payload))
+        controller.close()
+      },
+    }),
+    {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+      },
+    }
+  )
+}
+
+function createStreamingContext(): StreamingContext {
+  return {
+    messageId: 'msg-1',
+    accumulatedContent: '',
+    contentBlocks: [],
+    toolCalls: new Map(),
+    pendingToolPromises: new Map(),
+    currentThinkingBlock: null,
+    currentSubagentThinkingBlock: null,
+    isInThinkingBlock: false,
+    subAgentParentToolCallId: undefined,
+    subAgentParentStack: [],
+    subAgentContent: {},
+    subAgentToolCalls: {},
+    pendingContent: '',
+    streamComplete: false,
+    wasAborted: false,
+    errors: [],
+    activeFileIntent: null,
+    trace: new TraceCollector(),
+  }
+}
+
+describe('copilot go stream helpers', () => {
+  beforeEach(() => {
+    vi.stubGlobal('fetch', vi.fn())
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('decodes complete escapes and stops at incomplete unicode escapes', () => {
+    expect(decodeJsonStringPrefix('hello\\nworld')).toBe('hello\nworld')
+    expect(decodeJsonStringPrefix('emoji \\u263A')).toBe('emoji ☺')
+    expect(decodeJsonStringPrefix('partial \\u26')).toBe('partial ')
+  })
+
+  it('extracts the streamed edit_content prefix from partial JSON', () => {
+    expect(extractEditContent('{"content":"hello\\nwor')).toBe('hello\nwor')
+    expect(extractEditContent('{"content":"tab\\tvalue"}')).toBe('tab\tvalue')
+  })
+
+  it('emits full snapshots for append (sidebar viewer uses replace mode; no delta merge)', () => {
+    expect(buildPreviewContentUpdate('hello', 'hello world', 100, 200, 'append')).toEqual({
+      content: 'hello world',
+      contentMode: 'snapshot',
+      lastSnapshotAt: 200,
+    })
+  })
+
+  it('emits deltas for update when the preview extends the previous text', () => {
+    expect(buildPreviewContentUpdate('hello', 'hello world', 100, 200, 'update')).toEqual({
+      content: ' world',
+      contentMode: 'delta',
+      lastSnapshotAt: 100,
+    })
+  })
+
+  it('falls back to snapshots for patches and divergent content', () => {
+    expect(buildPreviewContentUpdate('hello', 'goodbye', 100, 200, 'update')).toEqual({
+      content: 'goodbye',
+      contentMode: 'snapshot',
+      lastSnapshotAt: 200,
+    })
+
+    expect(buildPreviewContentUpdate('hello', 'hello world', 100, 200, 'patch')).toEqual({
+      content: 'hello world',
+      contentMode: 'snapshot',
+      lastSnapshotAt: 200,
+    })
+  })
+
+  it('drops duplicate tool_result events before forwarding them', async () => {
+    const toolResult = createEvent({
+      streamId: 'stream-1',
+      cursor: '1',
+      seq: 1,
+      requestId: 'req-1',
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'tool-result-dedupe',
+        toolName: 'search_online',
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.result,
+        success: true,
+        output: { value: 'ok' },
+      },
+    })
+    const complete = createEvent({
+      streamId: 'stream-1',
+      cursor: '2',
+      seq: 2,
+      requestId: 'req-1',
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: MothershipStreamV1CompletionStatus.complete,
+      },
+    })
+
+    vi.mocked(fetch).mockResolvedValueOnce(createSseResponse([toolResult, toolResult, complete]))
+
+    const onEvent = vi.fn()
+    const context = createStreamingContext()
+    const execContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+    }
+
+    await runStreamLoop('https://example.com/mothership/stream', {}, context, execContext, {
+      onEvent,
+      timeout: 1000,
+    })
+
+    expect(onEvent.mock.calls.map(([event]) => event.type)).toEqual([
+      MothershipStreamV1EventType.tool,
+      MothershipStreamV1EventType.complete,
+    ])
+    expect(onEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.tool,
+        payload: expect.objectContaining({
+          toolCallId: 'tool-result-dedupe',
+          phase: MothershipStreamV1ToolPhase.result,
+        }),
+      })
+    )
+    expect(context.toolCalls.get('tool-result-dedupe')).toEqual(
+      expect.objectContaining({
+        id: 'tool-result-dedupe',
+        name: 'search_online',
+        status: MothershipStreamV1ToolOutcome.success,
+        result: { success: true, output: { value: 'ok' } },
+      })
+    )
+  })
+
+  it('fails closed when the shared stream ends before a terminal event', async () => {
+    const textEvent = createEvent({
+      streamId: 'stream-1',
+      cursor: '1',
+      seq: 1,
+      requestId: 'req-1',
+      type: MothershipStreamV1EventType.text,
+      payload: {
+        channel: 'assistant',
+        text: 'partial response',
+      },
+    })
+
+    vi.mocked(fetch).mockResolvedValueOnce(createSseResponse([textEvent]))
+
+    const context = createStreamingContext()
+    const execContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+    }
+
+    await expect(
+      runStreamLoop('https://example.com/mothership/stream', {}, context, execContext, {
+        timeout: 1000,
+      })
+    ).rejects.toThrow('Copilot backend stream ended before a terminal event')
+    expect(
+      context.errors.some((message) =>
+        message.includes('Copilot backend stream ended before a terminal event')
+      )
+    ).toBe(true)
+  })
+
+  it('fails closed when the shared stream receives an invalid event', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      createSseResponse([
+        {
+          v: 1,
+          type: MothershipStreamV1EventType.tool,
+          seq: 1,
+          ts: '2026-01-01T00:00:00.000Z',
+          stream: { streamId: 'stream-1', cursor: '1' },
+          payload: {
+            phase: MothershipStreamV1ToolPhase.result,
+          },
+        },
+      ])
+    )
+
+    const context = createStreamingContext()
+    const execContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+    }
+
+    await expect(
+      runStreamLoop('https://example.com/mothership/stream', {}, context, execContext, {
+        timeout: 1000,
+      })
+    ).rejects.toThrow('Received invalid stream event on shared path')
+    expect(
+      context.errors.some((message) =>
+        message.includes('Received invalid stream event on shared path')
+      )
+    ).toBe(true)
+  })
+
+  it('fails closed when the shared stream receives malformed JSON', async () => {
+    vi.mocked(fetch).mockResolvedValueOnce(
+      createRawSseResponse('data: {"v":1,"type":"text","payload":\n\n')
+    )
+
+    const context = createStreamingContext()
+    const execContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+    }
+
+    await expect(
+      runStreamLoop('https://example.com/mothership/stream', {}, context, execContext, {
+        timeout: 1000,
+      })
+    ).rejects.toThrow('Failed to parse SSE event JSON')
+    expect(
+      context.errors.some((message) => message.includes('Failed to parse SSE event JSON'))
+    ).toBe(true)
+  })
+})
diff --git a/apps/sim/lib/copilot/request/go/stream.ts b/apps/sim/lib/copilot/request/go/stream.ts
new file mode 100644
index 00000000000..32d1c47b15b
--- /dev/null
+++ b/apps/sim/lib/copilot/request/go/stream.ts
@@ -0,0 +1,304 @@
+import { createLogger } from '@sim/logger'
+import { ORCHESTRATION_TIMEOUT_MS } from '@/lib/copilot/constants'
+import { MothershipStreamV1SpanLifecycleEvent } from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  buildPreviewContentUpdate,
+  createFilePreviewAdapterState,
+  decodeJsonStringPrefix,
+  extractEditContent,
+  processFilePreviewStreamEvent,
+} from '@/lib/copilot/request/go/file-preview-adapter'
+import { FatalSseEventError, processSSEStream } from '@/lib/copilot/request/go/parser'
+import {
+  handleSubagentRouting,
+  sseHandlers,
+  subAgentHandlers,
+} from '@/lib/copilot/request/handlers'
+import {
+  eventToStreamEvent,
+  isSubagentSpanStreamEvent,
+  parsePersistedStreamEventEnvelope,
+} from '@/lib/copilot/request/session'
+import { shouldSkipToolCallEvent, shouldSkipToolResultEvent } from '@/lib/copilot/request/sse-utils'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+
+const logger = createLogger('CopilotGoStream')
+
+export { buildPreviewContentUpdate, decodeJsonStringPrefix, extractEditContent }
+
+type JsonRecord = Record<string, unknown>
+
+type SubagentSpanData = {
+  pending?: boolean
+  toolCallId?: string
+}
+
+function asJsonRecord(value: unknown): JsonRecord | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as JsonRecord)
+    : undefined
+}
+
+function parseSubagentSpanData(value: unknown): SubagentSpanData | undefined {
+  const data = asJsonRecord(value)
+  if (!data) {
+    return undefined
+  }
+
+  const toolCallId = typeof data.tool_call_id === 'string' ? data.tool_call_id : undefined
+  const pending = typeof data.pending === 'boolean' ? data.pending : undefined
+
+  return {
+    ...(toolCallId ? { toolCallId } : {}),
+    ...(pending !== undefined ? { pending } : {}),
+  }
+}
+
+export class CopilotBackendError extends Error {
+  status?: number
+  body?: string
+
+  constructor(message: string, options?: { status?: number; body?: string }) {
+    super(message)
+    this.name = 'CopilotBackendError'
+    this.status = options?.status
+    this.body = options?.body
+  }
+}
+
+export class BillingLimitError extends Error {
+  constructor(public readonly userId: string) {
+    super('Usage limit reached')
+    this.name = 'BillingLimitError'
+  }
+}
+
+/**
+ * Options for the shared stream processing loop.
+ */
+export interface StreamLoopOptions extends OrchestratorOptions {
+  /**
+   * Called for each normalized event BEFORE standard handler dispatch.
+   * Return true to skip the default handler for this event.
+   */
+  onBeforeDispatch?: (event: StreamEvent, context: StreamingContext) => boolean | undefined
+  /**
+   * Called when the Go backend's trace ID (go_trace_id) is first received via SSE.
+   */
+  onGoTraceId?: (goTraceId: string) => void
+}
+
+/**
+ * Run the SSE stream processing loop against the Go backend.
+ *
+ * Handles: fetch -> parse -> normalize -> dedupe -> subagent routing -> handler dispatch.
+ * Callers provide the fetch URL/options and can intercept events via onBeforeDispatch.
+ * Feature-specific normalization runs through dedicated adapters before the raw event is forwarded.
+ */
+export async function runStreamLoop(
+  fetchUrl: string,
+  fetchOptions: RequestInit,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: StreamLoopOptions
+): Promise<void> {
+  const { timeout = ORCHESTRATION_TIMEOUT_MS, abortSignal } = options
+  const filePreviewAdapterState = createFilePreviewAdapterState()
+
+  const fetchSpan = context.trace.startSpan(
+    `HTTP Request → ${new URL(fetchUrl).pathname}`,
+    'sim.http.fetch',
+    { url: fetchUrl }
+  )
+  const response = await fetch(fetchUrl, {
+    ...fetchOptions,
+    signal: abortSignal,
+  })
+
+  if (!response.ok) {
+    context.trace.endSpan(fetchSpan, 'error')
+    const errorText = await response.text().catch(() => '')
+
+    if (response.status === 402) {
+      throw new BillingLimitError(execContext.userId)
+    }
+
+    throw new CopilotBackendError(
+      `Copilot backend error (${response.status}): ${errorText || response.statusText}`,
+      { status: response.status, body: errorText || response.statusText }
+    )
+  }
+
+  if (!response.body) {
+    context.trace.endSpan(fetchSpan, 'error')
+    throw new CopilotBackendError('Copilot backend response missing body')
+  }
+
+  context.trace.endSpan(fetchSpan)
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+
+  const timeoutId = setTimeout(() => {
+    context.errors.push('Request timed out')
+    context.streamComplete = true
+    reader.cancel().catch(() => {})
+  }, timeout)
+
+  try {
+    await processSSEStream(reader, decoder, abortSignal, async (raw) => {
+      if (abortSignal?.aborted) {
+        context.wasAborted = true
+        return true
+      }
+
+      const parsedEvent = parsePersistedStreamEventEnvelope(raw)
+      if (!parsedEvent.ok) {
+        const detail = [parsedEvent.message, ...(parsedEvent.errors ?? [])]
+          .filter(Boolean)
+          .join('; ')
+        const failureMessage = `Received invalid stream event on shared path: ${detail}`
+        context.errors.push(failureMessage)
+        logger.error('Received invalid stream event on shared path', {
+          reason: parsedEvent.reason,
+          message: parsedEvent.message,
+          errors: parsedEvent.errors,
+        })
+        throw new FatalSseEventError(failureMessage)
+      }
+
+      const envelope = parsedEvent.event
+      const streamEvent = eventToStreamEvent(envelope)
+      if (envelope.trace?.requestId) {
+        const prev = context.requestId
+        context.requestId = envelope.trace.requestId
+        context.trace.setGoTraceId(envelope.trace.requestId)
+        if (envelope.trace.requestId !== prev) {
+          options.onGoTraceId?.(envelope.trace.requestId)
+        }
+      }
+
+      if (shouldSkipToolCallEvent(streamEvent) || shouldSkipToolResultEvent(streamEvent)) {
+        return
+      }
+
+      await processFilePreviewStreamEvent({
+        streamId: envelope.stream.streamId,
+        streamEvent,
+        context,
+        execContext,
+        options,
+        state: filePreviewAdapterState,
+      })
+
+      try {
+        await options.onEvent?.(streamEvent)
+      } catch (error) {
+        logger.warn('Failed to forward stream event', {
+          type: streamEvent.type,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+
+      // Yield a macrotask so Node.js flushes the HTTP response buffer to
+      // the browser. Microtask yields (await Promise.resolve()) are not
+      // enough — the I/O layer needs a full event loop tick to write.
+      await new Promise<void>((resolve) => setImmediate(resolve))
+
+      if (options.onBeforeDispatch?.(streamEvent, context)) {
+        return context.streamComplete || undefined
+      }
+
+      if (isSubagentSpanStreamEvent(streamEvent)) {
+        const spanData = parseSubagentSpanData(streamEvent.payload.data)
+        const toolCallId = streamEvent.scope?.parentToolCallId || spanData?.toolCallId
+        const subagentName = streamEvent.payload.agent
+        const spanEvt = streamEvent.payload.event
+        const isPendingPause = spanData?.pending === true
+        if (spanEvt === MothershipStreamV1SpanLifecycleEvent.start) {
+          const lastParent = context.subAgentParentStack[context.subAgentParentStack.length - 1]
+          const lastBlock = context.contentBlocks[context.contentBlocks.length - 1]
+          if (toolCallId) {
+            if (lastParent !== toolCallId) {
+              context.subAgentParentStack.push(toolCallId)
+            }
+            context.subAgentParentToolCallId = toolCallId
+            context.subAgentContent[toolCallId] ??= ''
+            context.subAgentToolCalls[toolCallId] ??= []
+          }
+          if (
+            subagentName &&
+            !(
+              lastParent === toolCallId &&
+              lastBlock?.type === 'subagent' &&
+              lastBlock.content === subagentName
+            )
+          ) {
+            context.contentBlocks.push({
+              type: 'subagent',
+              content: subagentName,
+              timestamp: Date.now(),
+            })
+          }
+          return
+        }
+        if (spanEvt === MothershipStreamV1SpanLifecycleEvent.end) {
+          if (isPendingPause) {
+            return
+          }
+          if (context.subAgentParentStack.length > 0) {
+            context.subAgentParentStack.pop()
+          } else {
+            logger.warn('subagent end without matching start')
+          }
+          context.subAgentParentToolCallId =
+            context.subAgentParentStack.length > 0
+              ? context.subAgentParentStack[context.subAgentParentStack.length - 1]
+              : undefined
+          return
+        }
+      }
+
+      if (handleSubagentRouting(streamEvent, context)) {
+        const handler = subAgentHandlers[streamEvent.type]
+        if (handler) {
+          await handler(streamEvent, context, execContext, options)
+        }
+        return context.streamComplete || undefined
+      }
+
+      const handler = sseHandlers[streamEvent.type]
+      if (handler) {
+        await handler(streamEvent, context, execContext, options)
+      }
+      return context.streamComplete || undefined
+    })
+
+    if (!context.streamComplete && !abortSignal?.aborted && !context.wasAborted) {
+      const streamPath = new URL(fetchUrl).pathname
+      const message = `Copilot backend stream ended before a terminal event on ${streamPath}`
+      context.errors.push(message)
+      logger.error('Copilot backend stream ended before a terminal event', {
+        path: streamPath,
+        requestId: context.requestId,
+        messageId: context.messageId,
+      })
+      throw new CopilotBackendError(message, { status: 503 })
+    }
+  } catch (error) {
+    if (error instanceof FatalSseEventError && !context.errors.includes(error.message)) {
+      context.errors.push(error.message)
+    }
+    throw error
+  } finally {
+    if (abortSignal?.aborted) {
+      context.wasAborted = true
+      await reader.cancel().catch(() => {})
+    }
+    clearTimeout(timeoutId)
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/complete.ts b/apps/sim/lib/copilot/request/handlers/complete.ts
new file mode 100644
index 00000000000..c2ea991ea1e
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/complete.ts
@@ -0,0 +1,28 @@
+import type { StreamHandler } from './types'
+import { flushSubagentThinkingBlock, flushThinkingBlock } from './types'
+
+export const handleCompleteEvent: StreamHandler = (event, context) => {
+  flushSubagentThinkingBlock(context)
+  flushThinkingBlock(context)
+  if (event.type !== 'complete') {
+    context.streamComplete = true
+    return
+  }
+
+  if (event.payload.usage) {
+    context.usage = {
+      prompt: (context.usage?.prompt || 0) + (event.payload.usage.input_tokens || 0),
+      completion: (context.usage?.completion || 0) + (event.payload.usage.output_tokens || 0),
+    }
+  }
+
+  if (event.payload.cost) {
+    context.cost = {
+      input: (context.cost?.input || 0) + (event.payload.cost.input || 0),
+      output: (context.cost?.output || 0) + (event.payload.cost.output || 0),
+      total: (context.cost?.total || 0) + (event.payload.cost.total || 0),
+    }
+  }
+
+  context.streamComplete = true
+}
diff --git a/apps/sim/lib/copilot/request/handlers/error.ts b/apps/sim/lib/copilot/request/handlers/error.ts
new file mode 100644
index 00000000000..1841fb42f73
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/error.ts
@@ -0,0 +1,16 @@
+import type { StreamHandler } from './types'
+import { flushSubagentThinkingBlock, flushThinkingBlock } from './types'
+
+export const handleErrorEvent: StreamHandler = (event, context) => {
+  flushSubagentThinkingBlock(context)
+  flushThinkingBlock(context)
+  if (event.type !== 'error') {
+    context.streamComplete = true
+    return
+  }
+  const message = event.payload.message || event.payload.error
+  if (message) {
+    context.errors.push(message)
+  }
+  context.streamComplete = true
+}
diff --git a/apps/sim/lib/copilot/request/handlers/handlers.test.ts b/apps/sim/lib/copilot/request/handlers/handlers.test.ts
new file mode 100644
index 00000000000..47c8ada2a91
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/handlers.test.ts
@@ -0,0 +1,727 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { TraceCollector } from '@/lib/copilot/request/trace'
+
+vi.mock('@sim/logger', () => loggerMock)
+
+const { isSimExecuted, executeTool, ensureHandlersRegistered } = vi.hoisted(() => ({
+  isSimExecuted: vi.fn().mockReturnValue(true),
+  executeTool: vi.fn().mockResolvedValue({ success: true, output: { ok: true } }),
+  ensureHandlersRegistered: vi.fn(),
+}))
+
+const { upsertAsyncToolCall, markAsyncToolRunning, completeAsyncToolCall } = vi.hoisted(() => ({
+  upsertAsyncToolCall: vi.fn(),
+  markAsyncToolRunning: vi.fn(),
+  completeAsyncToolCall: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/tool-executor', () => ({
+  isSimExecuted,
+  executeTool,
+  ensureHandlersRegistered,
+  getToolEntry: vi.fn().mockReturnValue(undefined),
+}))
+
+vi.mock('@/lib/copilot/async-runs/repository', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/copilot/async-runs/repository')>(
+    '@/lib/copilot/async-runs/repository'
+  )
+  return {
+    ...actual,
+    upsertAsyncToolCall,
+    markAsyncToolRunning,
+    completeAsyncToolCall,
+  }
+})
+
+import {
+  MothershipStreamV1AsyncToolRecordStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1ResourceOp,
+  MothershipStreamV1RunKind,
+  MothershipStreamV1TextChannel,
+  MothershipStreamV1ToolExecutor,
+  MothershipStreamV1ToolMode,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { sseHandlers, subAgentHandlers } from '@/lib/copilot/request/handlers'
+import type { ExecutionContext, StreamEvent, StreamingContext } from '@/lib/copilot/request/types'
+
+describe('sse-handlers tool lifecycle', () => {
+  let context: StreamingContext
+  let execContext: ExecutionContext
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    upsertAsyncToolCall.mockResolvedValue(null)
+    markAsyncToolRunning.mockResolvedValue(null)
+    completeAsyncToolCall.mockResolvedValue(null)
+    context = {
+      chatId: undefined,
+      messageId: 'msg-1',
+      accumulatedContent: '',
+      trace: new TraceCollector(),
+      contentBlocks: [],
+      toolCalls: new Map(),
+      pendingToolPromises: new Map(),
+      currentThinkingBlock: null,
+      isInThinkingBlock: false,
+      subAgentParentToolCallId: undefined,
+      subAgentParentStack: [],
+      subAgentContent: {},
+      subAgentToolCalls: {},
+      pendingContent: '',
+      streamComplete: false,
+      wasAborted: false,
+      errors: [],
+    }
+    execContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+    }
+  })
+
+  it('executes tool_call and emits tool_result', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-1',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+          ui: {
+            title: 'Reading foo.txt',
+            phaseLabel: 'Workspace',
+          },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    // tool_call fires execution without awaiting (fire-and-forget for parallel execution),
+    // so we flush pending microtasks before asserting
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+    expect(onEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.tool,
+        payload: expect.objectContaining({
+          toolCallId: 'tool-1',
+          success: true,
+          phase: MothershipStreamV1ToolPhase.result,
+        }),
+      })
+    )
+
+    const updated = context.toolCalls.get('tool-1')
+    expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.success)
+    expect(updated?.displayTitle).toBe('Reading foo.txt')
+    expect(updated?.phaseLabel).toBe('Workspace')
+    expect(updated?.result?.output).toEqual({ ok: true })
+    expect(context.contentBlocks.at(0)).toEqual(
+      expect.objectContaining({
+        type: 'tool_call',
+        toolCall: expect.objectContaining({
+          id: 'tool-1',
+          displayTitle: 'Reading foo.txt',
+          phaseLabel: 'Workspace',
+        }),
+      })
+    )
+  })
+
+  it('preserves primitive tool outputs through async completion persistence', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: 'done' })
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-primitive',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(completeAsyncToolCall).toHaveBeenCalledWith(
+      expect.objectContaining({
+        toolCallId: 'tool-primitive',
+        status: MothershipStreamV1AsyncToolRecordStatus.completed,
+        result: 'done',
+        error: null,
+      })
+    )
+    expect(onEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.tool,
+        payload: expect.objectContaining({
+          toolCallId: 'tool-primitive',
+          phase: MothershipStreamV1ToolPhase.result,
+          success: true,
+          output: 'done',
+        }),
+      })
+    )
+
+    const updated = context.toolCalls.get('tool-primitive')
+    expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.success)
+    expect(updated?.result?.output).toBe('done')
+  })
+
+  it('does not add hidden tool calls to content blocks', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { skill: 'ok' } })
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-hidden',
+          toolName: 'load_agent_skill',
+          arguments: { skill_name: 'markdown-writing' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+    expect(context.contentBlocks).toEqual([])
+    expect(context.toolCalls.get('tool-hidden')?.name).toBe('load_agent_skill')
+  })
+
+  it('updates stored params when a subagent generating event is followed by the final tool call', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+    context.subAgentParentToolCallId = 'parent-1'
+    context.subAgentParentStack = ['parent-1']
+    context.toolCalls.set('parent-1', {
+      id: 'parent-1',
+      name: 'workflow',
+      status: 'pending',
+      startTime: Date.now(),
+    })
+
+    await subAgentHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'workflow' },
+        payload: {
+          toolCallId: 'sub-tool-1',
+          toolName: 'create_workflow',
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+          status: 'generating',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await subAgentHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'workflow' },
+        payload: {
+          toolCallId: 'sub-tool-1',
+          toolName: 'create_workflow',
+          arguments: { name: 'Example Workflow' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+          status: 'executing',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledWith(
+      'create_workflow',
+      { name: 'Example Workflow' },
+      expect.any(Object)
+    )
+    expect(context.toolCalls.get('sub-tool-1')?.params).toEqual({ name: 'Example Workflow' })
+    expect(context.subAgentToolCalls['parent-1']?.[0]?.params).toEqual({
+      name: 'Example Workflow',
+    })
+  })
+
+  it('routes subagent text using the event scope parent tool call id', async () => {
+    context.subAgentParentToolCallId = 'wrong-parent'
+    context.subAgentContent['parent-1'] = ''
+
+    await subAgentHandlers.text(
+      {
+        type: MothershipStreamV1EventType.text,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'deploy' },
+        payload: {
+          channel: MothershipStreamV1TextChannel.assistant,
+          text: 'hello from deploy',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    expect(context.subAgentContent['parent-1']).toBe('hello from deploy')
+    expect(context.contentBlocks.at(-1)).toEqual(
+      expect.objectContaining({
+        type: 'subagent_text',
+        content: 'hello from deploy',
+      })
+    )
+  })
+
+  it('routes main assistant text with no scope into accumulatedContent', async () => {
+    await sseHandlers.text(
+      {
+        type: MothershipStreamV1EventType.text,
+        payload: {
+          channel: MothershipStreamV1TextChannel.assistant,
+          text: 'hello from main',
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    expect(context.accumulatedContent).toBe('hello from main')
+    expect(context.contentBlocks.at(-1)).toEqual(
+      expect.objectContaining({
+        type: 'text',
+        content: 'hello from main',
+      })
+    )
+  })
+
+  it('routes subagent tool calls using the event scope parent tool call id', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+    context.subAgentParentToolCallId = 'wrong-parent'
+    context.toolCalls.set('parent-1', {
+      id: 'parent-1',
+      name: 'deploy',
+      status: 'pending',
+      startTime: Date.now(),
+    })
+
+    await subAgentHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId: 'deploy' },
+        payload: {
+          toolCallId: 'sub-tool-scope-1',
+          toolName: 'read',
+          arguments: { path: 'workflow.json' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(context.subAgentToolCalls['parent-1']?.[0]?.id).toBe('sub-tool-scope-1')
+  })
+
+  it('skips duplicate tool_call after result', async () => {
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+
+    const event = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'tool-dup',
+        toolName: ReadTool.id,
+        arguments: { workflowId: 'workflow-1' },
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.call,
+      },
+    }
+
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+  })
+
+  it('marks an in-flight tool as cancelled when aborted mid-execution', async () => {
+    const abortController = new AbortController()
+    const userStopController = new AbortController()
+    execContext.abortSignal = abortController.signal
+    execContext.userStopSignal = userStopController.signal
+
+    executeTool.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          setTimeout(() => resolve({ success: true, output: { ok: true } }), 0)
+        })
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-cancel',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      {
+        interactive: false,
+        timeout: 1000,
+        abortSignal: abortController.signal,
+        userStopSignal: userStopController.signal,
+      }
+    )
+
+    userStopController.abort()
+    abortController.abort()
+    await new Promise((resolve) => setTimeout(resolve, 10))
+
+    const updated = context.toolCalls.get('tool-cancel')
+    expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.cancelled)
+    expect(updated?.result).toEqual({ success: false })
+    expect(updated?.error).toBe('Request aborted during tool execution')
+  })
+
+  it('does not replace an in-flight pending promise on duplicate tool_call', async () => {
+    let resolveTool: ((value: { success: boolean; output: { ok: boolean } }) => void) | undefined
+    executeTool.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveTool = resolve
+        })
+    )
+
+    const event = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'tool-inflight',
+        toolName: ReadTool.id,
+        arguments: { workflowId: 'workflow-1' },
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.call,
+      },
+    }
+
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const firstPromise = context.pendingToolPromises.get('tool-inflight')
+    expect(firstPromise).toBeDefined()
+
+    await sseHandlers.tool(event as StreamEvent, context, execContext, { interactive: false })
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+    expect(context.pendingToolPromises.get('tool-inflight')).toBe(firstPromise)
+
+    resolveTool?.({ success: true, output: { ok: true } })
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(context.pendingToolPromises.has('tool-inflight')).toBe(false)
+  })
+
+  it('still executes the tool when async row upsert fails', async () => {
+    upsertAsyncToolCall.mockRejectedValueOnce(new Error('db down'))
+    executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-upsert-fail',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent: vi.fn(), interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledTimes(1)
+    expect(context.toolCalls.get('tool-upsert-fail')?.status).toBe(
+      MothershipStreamV1ToolOutcome.success
+    )
+  })
+
+  it('does not execute a tool if a terminal tool_result arrives before local execution starts', async () => {
+    let resolveUpsert: ((value: null) => void) | undefined
+    upsertAsyncToolCall.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveUpsert = resolve
+        })
+    )
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-race',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-race',
+          toolName: ReadTool.id,
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.result,
+          success: true,
+          output: { ok: true },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    resolveUpsert?.(null)
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).not.toHaveBeenCalled()
+    expect(context.toolCalls.get('tool-race')?.status).toBe(MothershipStreamV1ToolOutcome.success)
+    expect(context.toolCalls.get('tool-race')?.result?.output).toEqual({ ok: true })
+  })
+
+  it('does not execute a tool if a tool_result arrives before the tool_call event', async () => {
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-early-result',
+          toolName: ReadTool.id,
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.result,
+          success: true,
+          output: { ok: true },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-early-result',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).not.toHaveBeenCalled()
+    expect(context.toolCalls.get('tool-early-result')?.status).toBe(
+      MothershipStreamV1ToolOutcome.success
+    )
+  })
+
+  it('reads canonical tool result errors from the error field', async () => {
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-output-only',
+          toolName: ReadTool.id,
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.result,
+          success: false,
+          error: 'output-failure',
+          output: { detail: 'extra-context' },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent: vi.fn(), interactive: false, timeout: 1000 }
+    )
+
+    const updated = context.toolCalls.get('tool-output-only')
+    expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.error)
+    expect(updated?.result?.output).toEqual({ detail: 'extra-context' })
+    expect(updated?.error).toBe('output-failure')
+  })
+
+  it('preserves skipped tool results from the stream contract', async () => {
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-skipped',
+          toolName: ReadTool.id,
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.result,
+          status: MothershipStreamV1ToolOutcome.skipped,
+          success: true,
+          output: { detached: true },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent: vi.fn(), interactive: false, timeout: 1000 }
+    )
+
+    const updated = context.toolCalls.get('tool-skipped')
+    expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.skipped)
+    expect(updated?.result?.output).toEqual({ detached: true })
+    expect(updated?.error).toBeUndefined()
+  })
+
+  it('executes dynamic sim tools based on payload executor', async () => {
+    isSimExecuted.mockReturnValueOnce(false)
+    executeTool.mockResolvedValueOnce({ success: true, output: { emails: [] } })
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-dynamic-sim',
+          toolName: 'gmail_read',
+          arguments: { maxResults: 10 },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    expect(executeTool).toHaveBeenCalledWith('gmail_read', { maxResults: 10 }, expect.any(Object))
+    expect(context.toolCalls.get('tool-dynamic-sim')?.status).toBe(
+      MothershipStreamV1ToolOutcome.success
+    )
+  })
+
+  it('clears pending continuation state when a run resumes', async () => {
+    context.awaitingAsyncContinuation = {
+      checkpointId: 'cp-1',
+      executionId: 'exec-1',
+      runId: 'run-1',
+      pendingToolCallIds: ['tool-1'],
+    }
+    context.streamComplete = true
+
+    await sseHandlers.run(
+      {
+        type: MothershipStreamV1EventType.run,
+        payload: {
+          kind: MothershipStreamV1RunKind.resumed,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: false, timeout: 1000 }
+    )
+
+    expect(context.awaitingAsyncContinuation).toBeUndefined()
+    expect(context.streamComplete).toBe(false)
+  })
+
+  it('routes resource events through an explicit main-lane handler', async () => {
+    expect(() =>
+      sseHandlers.resource(
+        {
+          type: MothershipStreamV1EventType.resource,
+          payload: {
+            op: MothershipStreamV1ResourceOp.upsert,
+            resource: {
+              type: 'file',
+              id: 'file-1',
+              title: 'Document',
+            },
+          },
+        } satisfies StreamEvent,
+        context,
+        execContext,
+        { interactive: false, timeout: 1000 }
+      )
+    ).not.toThrow()
+  })
+})
diff --git a/apps/sim/lib/copilot/request/handlers/index.ts b/apps/sim/lib/copilot/request/handlers/index.ts
new file mode 100644
index 00000000000..ffeeab5d1d8
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/index.ts
@@ -0,0 +1,52 @@
+import { createLogger } from '@sim/logger'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent, StreamingContext } from '@/lib/copilot/request/types'
+import { handleCompleteEvent } from './complete'
+import { handleErrorEvent } from './error'
+import { handleResourceEvent } from './resource'
+import { handleRunEvent } from './run'
+import { handleSessionEvent } from './session'
+import { handleSpanEvent } from './span'
+import { handleTextEvent } from './text'
+import { handleToolEvent } from './tool'
+import type { StreamHandler } from './types'
+
+export type { StreamHandler, ToolScope } from './types'
+
+const logger = createLogger('CopilotHandlerRouting')
+
+export const sseHandlers: Record<string, StreamHandler> = {
+  [MothershipStreamV1EventType.session]: handleSessionEvent,
+  [MothershipStreamV1EventType.tool]: (e, c, ec, o) => handleToolEvent(e, c, ec, o, 'main'),
+  [MothershipStreamV1EventType.text]: handleTextEvent('main'),
+  [MothershipStreamV1EventType.resource]: handleResourceEvent,
+  [MothershipStreamV1EventType.run]: handleRunEvent,
+  [MothershipStreamV1EventType.complete]: handleCompleteEvent,
+  [MothershipStreamV1EventType.error]: handleErrorEvent,
+  [MothershipStreamV1EventType.span]: handleSpanEvent,
+}
+
+export const subAgentHandlers: Record<string, StreamHandler> = {
+  [MothershipStreamV1EventType.text]: handleTextEvent('subagent'),
+  [MothershipStreamV1EventType.tool]: (e, c, ec, o) => handleToolEvent(e, c, ec, o, 'subagent'),
+  [MothershipStreamV1EventType.span]: handleSpanEvent,
+}
+
+export function handleSubagentRouting(event: StreamEvent, context: StreamingContext): boolean {
+  if (event.scope?.lane !== 'subagent') return false
+
+  // Keep the latest scoped parent on hand for legacy callers, but subagent
+  // handlers should prefer the event-local scope for correctness.
+  if (event.scope?.parentToolCallId) {
+    context.subAgentParentToolCallId = event.scope.parentToolCallId
+  }
+
+  if (!context.subAgentParentToolCallId) {
+    logger.warn('Subagent event missing parent tool call', {
+      type: event.type,
+      subagent: event.scope?.agentId,
+    })
+    return false
+  }
+  return true
+}
diff --git a/apps/sim/lib/copilot/request/handlers/resource.ts b/apps/sim/lib/copilot/request/handlers/resource.ts
new file mode 100644
index 00000000000..9ae8d13d48b
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/resource.ts
@@ -0,0 +1,7 @@
+import type { StreamHandler } from './types'
+
+export const handleResourceEvent: StreamHandler = (event) => {
+  if (event.type !== 'resource') {
+    return
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/run.ts b/apps/sim/lib/copilot/request/handlers/run.ts
new file mode 100644
index 00000000000..830d935e4cc
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/run.ts
@@ -0,0 +1,70 @@
+import { createLogger } from '@sim/logger'
+import {
+  MothershipStreamV1RunKind,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamHandler } from './types'
+import { addContentBlock } from './types'
+
+const logger = createLogger('CopilotRunHandler')
+
+export const handleRunEvent: StreamHandler = (event, context) => {
+  if (event.type !== 'run') {
+    return
+  }
+
+  if (event.payload.kind === MothershipStreamV1RunKind.checkpoint_pause) {
+    const frames = (event.payload.frames ?? []).map((frame) => ({
+      parentToolCallId: frame.parentToolCallId,
+      parentToolName: frame.parentToolName,
+      pendingToolIds: frame.pendingToolIds,
+    }))
+
+    context.awaitingAsyncContinuation = {
+      checkpointId: event.payload.checkpointId,
+      executionId: event.payload.executionId || context.executionId,
+      runId: event.payload.runId || context.runId,
+      pendingToolCallIds: event.payload.pendingToolCallIds,
+      frames: frames.length > 0 ? frames : undefined,
+    }
+    logger.info('Received checkpoint pause', {
+      checkpointId: context.awaitingAsyncContinuation.checkpointId,
+      executionId: context.awaitingAsyncContinuation.executionId,
+      runId: context.awaitingAsyncContinuation.runId,
+      pendingToolCallIds: context.awaitingAsyncContinuation.pendingToolCallIds,
+      frameCount: frames.length,
+    })
+    context.streamComplete = true
+    return
+  }
+
+  if (event.payload.kind === MothershipStreamV1RunKind.compaction_start) {
+    addContentBlock(context, {
+      type: 'tool_call',
+      toolCall: {
+        id: `compaction-${Date.now()}`,
+        name: 'context_compaction',
+        status: 'executing',
+      },
+    })
+    return
+  }
+
+  if (event.payload.kind === MothershipStreamV1RunKind.resumed) {
+    context.awaitingAsyncContinuation = undefined
+    context.streamComplete = false
+    logger.info('Received run resumed event')
+    return
+  }
+
+  if (event.payload.kind === MothershipStreamV1RunKind.compaction_done) {
+    addContentBlock(context, {
+      type: 'tool_call',
+      toolCall: {
+        id: `compaction-${Date.now()}`,
+        name: 'context_compaction',
+        status: MothershipStreamV1ToolOutcome.success,
+      },
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/session.ts b/apps/sim/lib/copilot/request/handlers/session.ts
new file mode 100644
index 00000000000..972594b2ad4
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/session.ts
@@ -0,0 +1,14 @@
+import { MothershipStreamV1SessionKind } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamHandler } from './types'
+
+export const handleSessionEvent: StreamHandler = (event, context, execContext) => {
+  if (event.type !== 'session' || event.payload.kind !== MothershipStreamV1SessionKind.chat) {
+    return
+  }
+
+  const chatId = event.payload.chatId
+  context.chatId = chatId
+  if (chatId) {
+    execContext.chatId = chatId
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/span.ts b/apps/sim/lib/copilot/request/handlers/span.ts
new file mode 100644
index 00000000000..e684b232582
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/span.ts
@@ -0,0 +1,3 @@
+import type { StreamHandler } from './types'
+
+export const handleSpanEvent: StreamHandler = () => {}
diff --git a/apps/sim/lib/copilot/request/handlers/text.ts b/apps/sim/lib/copilot/request/handlers/text.ts
new file mode 100644
index 00000000000..e81ab238884
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/text.ts
@@ -0,0 +1,66 @@
+import { MothershipStreamV1TextChannel } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamHandler, ToolScope } from './types'
+import {
+  addContentBlock,
+  flushSubagentThinkingBlock,
+  flushThinkingBlock,
+  getScopedParentToolCallId,
+} from './types'
+
+export function handleTextEvent(scope: ToolScope): StreamHandler {
+  return (event, context) => {
+    if (event.type !== 'text') {
+      return
+    }
+
+    const chunk = event.payload.text
+    if (!chunk) {
+      return
+    }
+
+    if (scope === 'subagent') {
+      const parentToolCallId = getScopedParentToolCallId(event, context)
+      if (!parentToolCallId) return
+      if (event.payload.channel === MothershipStreamV1TextChannel.thinking) {
+        if (!context.currentSubagentThinkingBlock) {
+          context.currentSubagentThinkingBlock = {
+            type: 'subagent_thinking',
+            content: '',
+            timestamp: Date.now(),
+          }
+        }
+        context.currentSubagentThinkingBlock.content = `${context.currentSubagentThinkingBlock.content || ''}${chunk}`
+        return
+      }
+      if (context.currentSubagentThinkingBlock) {
+        flushSubagentThinkingBlock(context)
+      }
+      if (context.isInThinkingBlock) {
+        flushThinkingBlock(context)
+      }
+      context.subAgentContent[parentToolCallId] =
+        (context.subAgentContent[parentToolCallId] || '') + chunk
+      addContentBlock(context, { type: 'subagent_text', content: chunk })
+      return
+    }
+
+    if (event.payload.channel === MothershipStreamV1TextChannel.thinking) {
+      if (!context.currentThinkingBlock) {
+        context.currentThinkingBlock = {
+          type: 'thinking',
+          content: '',
+          timestamp: Date.now(),
+        }
+        context.isInThinkingBlock = true
+      }
+      context.currentThinkingBlock.content = `${context.currentThinkingBlock.content || ''}${chunk}`
+      return
+    }
+
+    if (context.isInThinkingBlock) {
+      flushThinkingBlock(context)
+    }
+    context.accumulatedContent += chunk
+    addContentBlock(context, { type: 'text', content: chunk })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/tool.ts b/apps/sim/lib/copilot/request/handlers/tool.ts
new file mode 100644
index 00000000000..a269d7b54bc
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/tool.ts
@@ -0,0 +1,415 @@
+import { createLogger } from '@sim/logger'
+import { upsertAsyncToolCall } from '@/lib/copilot/async-runs/repository'
+import { STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1AsyncToolRecordStatus,
+  type MothershipStreamV1ToolCallDescriptor,
+  MothershipStreamV1ToolOutcome,
+  type MothershipStreamV1ToolResultPayload,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  isToolArgsDeltaStreamEvent,
+  isToolCallStreamEvent,
+  isToolResultStreamEvent,
+  TOOL_CALL_STATUS,
+} from '@/lib/copilot/request/session'
+import { markToolResultSeen, wasToolResultSeen } from '@/lib/copilot/request/sse-utils'
+import { setTerminalToolCallState } from '@/lib/copilot/request/tool-call-state'
+import { executeToolAndReport, waitForToolCompletion } from '@/lib/copilot/request/tools/executor'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+  ToolCallState,
+} from '@/lib/copilot/request/types'
+import { getToolEntry, isSimExecuted } from '@/lib/copilot/tool-executor'
+import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
+import { isWorkflowToolName } from '@/lib/copilot/tools/workflow-tools'
+import type { ToolScope } from './types'
+import {
+  abortPendingToolIfStreamDead,
+  addContentBlock,
+  emitSyntheticToolResult,
+  ensureTerminalToolCallState,
+  getScopedParentToolCallId,
+  getToolCallUI,
+  getToolResultErrorMessage,
+  handleClientCompletion,
+  inferToolSuccess,
+  registerPendingToolPromise,
+} from './types'
+
+const logger = createLogger('CopilotToolHandler')
+
+function applyToolDisplay(
+  toolCall: ToolCallState | undefined,
+  ui: { title?: string; phaseLabel?: string }
+): void {
+  if (!toolCall) return
+  if (ui.title) toolCall.displayTitle = ui.title
+  if (ui.phaseLabel) toolCall.phaseLabel = ui.phaseLabel
+}
+
+/**
+ * Unified tool event handler for both main and subagent scopes.
+ *
+ * The main vs subagent differences are:
+ * - Subagent requires a parentToolCallId and tracks tool calls in subAgentToolCalls
+ * - Subagent result phase also updates the subAgentToolCalls record
+ * - Subagent call phase stores in both subAgentToolCalls and context.toolCalls
+ * - Main call phase only stores in context.toolCalls
+ */
+export async function handleToolEvent(
+  event: StreamEvent,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions,
+  scope: ToolScope
+): Promise<void> {
+  const isSubagent = scope === 'subagent'
+  const parentToolCallId = isSubagent ? getScopedParentToolCallId(event, context) : undefined
+
+  if (isSubagent && !parentToolCallId) return
+
+  if (event.type !== 'tool') {
+    return
+  }
+
+  if (isToolArgsDeltaStreamEvent(event)) {
+    return
+  }
+
+  if (isToolResultStreamEvent(event)) {
+    handleResultPhase(event.payload, context, parentToolCallId)
+    return
+  }
+
+  if (!isToolCallStreamEvent(event)) {
+    return
+  }
+
+  await handleCallPhase(event.payload, context, execContext, options, parentToolCallId, scope)
+}
+
+function handleResultPhase(
+  data: MothershipStreamV1ToolResultPayload,
+  context: StreamingContext,
+  parentToolCallId: string | undefined
+): void {
+  const { toolCallId, toolName } = data
+  const mainToolCall = ensureTerminalToolCallState(context, toolCallId, toolName)
+  const { success, hasResultData } = inferToolSuccess(data)
+  let status: MothershipStreamV1ToolOutcome
+  if (data.status === MothershipStreamV1ToolOutcome.cancelled) {
+    status = MothershipStreamV1ToolOutcome.cancelled
+  } else if (data.status === MothershipStreamV1ToolOutcome.skipped) {
+    status = MothershipStreamV1ToolOutcome.skipped
+  } else if (data.status === MothershipStreamV1ToolOutcome.rejected) {
+    status = MothershipStreamV1ToolOutcome.rejected
+  } else {
+    status = success ? MothershipStreamV1ToolOutcome.success : MothershipStreamV1ToolOutcome.error
+  }
+  const endTime = Date.now()
+  const errorMessage =
+    !success && status !== MothershipStreamV1ToolOutcome.skipped
+      ? getToolResultErrorMessage(data) ||
+        (status === MothershipStreamV1ToolOutcome.cancelled
+          ? 'Tool cancelled'
+          : status === MothershipStreamV1ToolOutcome.rejected
+            ? 'Tool rejected'
+            : 'Tool failed')
+      : undefined
+
+  if (parentToolCallId) {
+    const toolCalls = context.subAgentToolCalls[parentToolCallId] || []
+    const subAgentToolCall = toolCalls.find((tc) => tc.id === toolCallId)
+    if (subAgentToolCall) {
+      setTerminalToolCallState(subAgentToolCall, {
+        status,
+        ...(hasResultData ? { output: data.output } : {}),
+        ...(errorMessage ? { error: errorMessage } : {}),
+        endTime,
+      })
+    }
+  }
+
+  setTerminalToolCallState(mainToolCall, {
+    status,
+    ...(hasResultData ? { output: data.output } : {}),
+    ...(errorMessage ? { error: errorMessage } : {}),
+    endTime,
+  })
+  markToolResultSeen(toolCallId)
+}
+
+async function handleCallPhase(
+  data: MothershipStreamV1ToolCallDescriptor,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions,
+  parentToolCallId: string | undefined,
+  scope: ToolScope
+): Promise<void> {
+  const { toolCallId, toolName } = data
+  const args = data.arguments
+  const isGenerating = data.status === TOOL_CALL_STATUS.generating
+  const isPartial = data.partial === true || isGenerating
+  const existing = context.toolCalls.get(toolCallId)
+  const isSubagent = scope === 'subagent'
+  const ui = getToolCallUI(data)
+
+  if (isSubagent) {
+    if (wasToolResultSeen(toolCallId) || existing?.endTime) {
+      if (existing && !existing.name && toolName) existing.name = toolName
+      if (existing && !existing.params && args) existing.params = args
+      applyToolDisplay(existing, ui)
+      return
+    }
+  } else {
+    if (
+      existing?.endTime ||
+      (existing && existing.status !== 'pending' && existing.status !== 'executing')
+    ) {
+      if (!existing.name && toolName) existing.name = toolName
+      if (!existing.params && args) existing.params = args
+      applyToolDisplay(existing, ui)
+      return
+    }
+  }
+
+  if (isSubagent) {
+    registerSubagentToolCall(context, toolCallId, toolName, args, parentToolCallId!, ui)
+  } else {
+    registerMainToolCall(context, toolCallId, toolName, args, existing, ui)
+  }
+
+  if (isPartial) return
+  if (!isSubagent && wasToolResultSeen(toolCallId)) return
+  if (context.pendingToolPromises.has(toolCallId) || existing?.status === 'executing') {
+    return
+  }
+
+  const toolCall = context.toolCalls.get(toolCallId)
+  if (!toolCall) return
+
+  const readPath = typeof args?.path === 'string' ? args.path : undefined
+  if (toolName === 'read' && readPath?.startsWith('internal/')) return
+
+  const { clientExecutable, simExecutable, internal } = ui
+  const catalogEntry = getToolEntry(toolName)
+  const isInternal = internal || catalogEntry?.internal === true
+  const staticSimExecuted = isSimExecuted(toolName)
+  const willDispatch = !isInternal && (staticSimExecuted || simExecutable || clientExecutable)
+  logger.info('Tool call routing decision', {
+    toolCallId,
+    toolName,
+    scope,
+    isSubagent,
+    parentToolCallId,
+    executor: data.executor,
+    clientExecutable,
+    simExecutable,
+    staticSimExecuted,
+    internal: isInternal,
+    hasPendingPromise: context.pendingToolPromises.has(toolCallId),
+    existingStatus: existing?.status,
+    willDispatch,
+  })
+  if (isInternal) return
+  if (!willDispatch) return
+
+  await dispatchToolExecution(
+    toolCall,
+    toolCallId,
+    toolName,
+    args,
+    context,
+    execContext,
+    options,
+    clientExecutable,
+    scope
+  )
+}
+
+function registerSubagentToolCall(
+  context: StreamingContext,
+  toolCallId: string,
+  toolName: string,
+  args: Record<string, unknown> | undefined,
+  parentToolCallId: string,
+  ui: { title?: string; phaseLabel?: string }
+): void {
+  if (!context.subAgentToolCalls[parentToolCallId]) {
+    context.subAgentToolCalls[parentToolCallId] = []
+  }
+  const hideFromUi = isToolHiddenInUi(toolName)
+  let toolCall = context.toolCalls.get(toolCallId)
+  if (toolCall) {
+    if (!toolCall.name && toolName) toolCall.name = toolName
+    if (args && !toolCall.params) toolCall.params = args
+    applyToolDisplay(toolCall, ui)
+  } else {
+    toolCall = {
+      id: toolCallId,
+      name: toolName,
+      status: 'pending',
+      params: args,
+      startTime: Date.now(),
+    }
+    applyToolDisplay(toolCall, ui)
+    context.toolCalls.set(toolCallId, toolCall)
+    const parentToolCall = context.toolCalls.get(parentToolCallId)
+    if (!hideFromUi) {
+      addContentBlock(context, {
+        type: 'tool_call',
+        toolCall,
+        calledBy: parentToolCall?.name,
+      })
+    }
+  }
+
+  const subagentToolCalls = context.subAgentToolCalls[parentToolCallId]
+  const existingSubagentToolCall = subagentToolCalls.find((tc) => tc.id === toolCallId)
+  if (existingSubagentToolCall) {
+    if (!existingSubagentToolCall.name && toolName) existingSubagentToolCall.name = toolName
+    if (args && !existingSubagentToolCall.params) existingSubagentToolCall.params = args
+    applyToolDisplay(existingSubagentToolCall, ui)
+  } else {
+    subagentToolCalls.push(toolCall)
+  }
+}
+
+function registerMainToolCall(
+  context: StreamingContext,
+  toolCallId: string,
+  toolName: string,
+  args: Record<string, unknown> | undefined,
+  existing: ToolCallState | undefined,
+  ui: { title?: string; phaseLabel?: string }
+): void {
+  const hideFromUi = isToolHiddenInUi(toolName)
+  if (existing) {
+    if (args && !existing.params) existing.params = args
+    applyToolDisplay(existing, ui)
+    if (
+      !hideFromUi &&
+      !context.contentBlocks.some((b) => b.type === 'tool_call' && b.toolCall?.id === toolCallId)
+    ) {
+      addContentBlock(context, { type: 'tool_call', toolCall: existing })
+    }
+  } else {
+    const created: ToolCallState = {
+      id: toolCallId,
+      name: toolName,
+      status: 'pending',
+      params: args,
+      startTime: Date.now(),
+    }
+    applyToolDisplay(created, ui)
+    context.toolCalls.set(toolCallId, created)
+    if (!hideFromUi) {
+      addContentBlock(context, { type: 'tool_call', toolCall: created })
+    }
+  }
+}
+
+async function dispatchToolExecution(
+  toolCall: ToolCallState,
+  toolCallId: string,
+  toolName: string,
+  args: Record<string, unknown> | undefined,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions,
+  clientExecutable: boolean,
+  scope: ToolScope
+): Promise<void> {
+  const scopeLabel = scope === 'subagent' ? 'subagent ' : ''
+
+  const fireToolExecution = () => {
+    const pendingPromise = (async () => {
+      return executeToolAndReport(toolCallId, context, execContext, options)
+    })().catch((err) => {
+      logger.error(`Parallel ${scopeLabel}tool execution failed`, {
+        toolCallId,
+        toolName,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      return {
+        status: MothershipStreamV1ToolOutcome.error,
+        message: 'Tool execution failed',
+        data: { error: 'Tool execution failed' },
+      }
+    })
+    registerPendingToolPromise(context, toolCallId, pendingPromise)
+  }
+
+  if (options.interactive === false) {
+    if (options.autoExecuteTools !== false) {
+      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
+        fireToolExecution()
+      }
+    }
+    return
+  }
+
+  if (clientExecutable) {
+    const delegateWorkflowRunToClient = isWorkflowToolName(toolName)
+    if (isSimExecuted(toolName) && !delegateWorkflowRunToClient) {
+      if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
+        fireToolExecution()
+      }
+    } else {
+      toolCall.status = 'executing'
+      const pendingPromise = (async () => {
+        await upsertAsyncToolCall({
+          runId: context.runId,
+          toolCallId,
+          toolName,
+          args,
+          status: MothershipStreamV1AsyncToolRecordStatus.running,
+        }).catch((err) => {
+          logger.warn(`Failed to persist async tool row for client-executable ${scopeLabel}tool`, {
+            toolCallId,
+            toolName,
+            error: err instanceof Error ? err.message : String(err),
+          })
+        })
+        const completion = await waitForToolCompletion(
+          toolCallId,
+          options.timeout || STREAM_TIMEOUT_MS,
+          options.abortSignal
+        )
+        handleClientCompletion(toolCall, toolCallId, completion)
+        await emitSyntheticToolResult(toolCallId, toolCall.name, completion, options)
+        return (
+          completion ?? {
+            status: MothershipStreamV1ToolOutcome.error,
+            message: 'Tool completion missing',
+            data: { error: 'Tool completion missing' },
+          }
+        )
+      })().catch((err) => {
+        logger.error(`Client-executable ${scopeLabel}tool wait failed`, {
+          toolCallId,
+          toolName,
+          error: err instanceof Error ? err.message : String(err),
+        })
+        return {
+          status: MothershipStreamV1ToolOutcome.error,
+          message: 'Tool wait failed',
+          data: { error: 'Tool wait failed' },
+        }
+      })
+      registerPendingToolPromise(context, toolCallId, pendingPromise)
+    }
+    return
+  }
+
+  if (options.autoExecuteTools !== false) {
+    if (!abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) {
+      fireToolExecution()
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/handlers/types.ts b/apps/sim/lib/copilot/request/handlers/types.ts
new file mode 100644
index 00000000000..fe7b93721f4
--- /dev/null
+++ b/apps/sim/lib/copilot/request/handlers/types.ts
@@ -0,0 +1,275 @@
+import { createLogger } from '@sim/logger'
+import type {
+  AsyncCompletionSignal,
+  AsyncTerminalCompletionSnapshot,
+} from '@/lib/copilot/async-runs/lifecycle'
+import { ASYNC_TOOL_CONFIRMATION_STATUS } from '@/lib/copilot/async-runs/lifecycle'
+import {
+  MothershipStreamV1EventType,
+  type MothershipStreamV1StreamScope,
+  type MothershipStreamV1ToolCallDescriptor,
+  MothershipStreamV1ToolExecutor,
+  MothershipStreamV1ToolMode,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+  type MothershipStreamV1ToolResultPayload,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { asRecord, markToolResultSeen } from '@/lib/copilot/request/sse-utils'
+import { setTerminalToolCallState } from '@/lib/copilot/request/tool-call-state'
+import type {
+  ContentBlock,
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+  ToolCallState,
+} from '@/lib/copilot/request/types'
+
+export type StreamHandler = (
+  event: StreamEvent,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions
+) => void | Promise<void>
+
+export type ToolScope = 'main' | MothershipStreamV1StreamScope['lane']
+
+const logger = createLogger('CopilotHandlerHelpers')
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+export function addContentBlock(
+  context: StreamingContext,
+  block: Omit<ContentBlock, 'timestamp'>
+): void {
+  context.contentBlocks.push({
+    ...block,
+    timestamp: Date.now(),
+  })
+}
+
+/**
+ * Flush any open thinking block into contentBlocks and clear the thinking state.
+ * Safe to call repeatedly.
+ */
+export function flushThinkingBlock(context: StreamingContext): void {
+  if (context.currentThinkingBlock) {
+    context.contentBlocks.push(context.currentThinkingBlock)
+  }
+  context.isInThinkingBlock = false
+  context.currentThinkingBlock = null
+}
+
+export function flushSubagentThinkingBlock(context: StreamingContext): void {
+  if (context.currentSubagentThinkingBlock) {
+    context.contentBlocks.push(context.currentSubagentThinkingBlock)
+  }
+  context.currentSubagentThinkingBlock = null
+}
+
+export function getScopedParentToolCallId(
+  event: StreamEvent,
+  context: StreamingContext
+): string | undefined {
+  return event.scope?.parentToolCallId || context.subAgentParentToolCallId
+}
+
+export function registerPendingToolPromise(
+  context: StreamingContext,
+  toolCallId: string,
+  pendingPromise: Promise<AsyncCompletionSignal>
+): void {
+  context.pendingToolPromises.set(toolCallId, pendingPromise)
+  pendingPromise.finally(() => {
+    if (context.pendingToolPromises.get(toolCallId) === pendingPromise) {
+      context.pendingToolPromises.delete(toolCallId)
+    }
+  })
+}
+
+/**
+ * When the Sim->Go stream is aborted, avoid starting server-side tool work and
+ * unblock the Go async waiter with a terminal 499 completion.
+ */
+export function abortPendingToolIfStreamDead(
+  toolCall: ToolCallState,
+  toolCallId: string,
+  options: OrchestratorOptions,
+  context: StreamingContext
+): boolean {
+  if (!options.abortSignal?.aborted && !context.wasAborted) {
+    return false
+  }
+  toolCall.status = MothershipStreamV1ToolOutcome.cancelled
+  toolCall.endTime = Date.now()
+  markToolResultSeen(toolCallId)
+  const toolSpan = context.trace.startSpan(toolCall.name || 'unknown_tool', 'tool.execute', {
+    toolCallId,
+    toolName: toolCall.name,
+    cancelReason: 'stream_dead_before_dispatch',
+    abortSignalAborted: options.abortSignal?.aborted ?? false,
+    abortReason: options.abortSignal?.aborted
+      ? String(options.abortSignal.reason ?? 'unknown')
+      : undefined,
+    wasAborted: context.wasAborted ?? false,
+  })
+  context.trace.endSpan(toolSpan, 'cancelled')
+  return true
+}
+
+/**
+ * Extract the `ui` object from a typed tool_call payload. The Go backend enriches
+ * tool_call events with `ui: { requiresConfirmation, clientExecutable, ... }`.
+ */
+export function getToolCallUI(data: MothershipStreamV1ToolCallDescriptor): {
+  requiresConfirmation: boolean
+  clientExecutable: boolean
+  simExecutable: boolean
+  internal: boolean
+  hidden: boolean
+  title?: string
+  phaseLabel?: string
+} {
+  const raw = asRecord(data.ui)
+  return {
+    requiresConfirmation: raw.requiresConfirmation === true || data.requiresConfirmation === true,
+    clientExecutable:
+      raw.clientExecutable === true || data.executor === MothershipStreamV1ToolExecutor.client,
+    simExecutable: data.executor === MothershipStreamV1ToolExecutor.sim,
+    internal: raw.internal === true,
+    hidden: raw.hidden === true,
+    title: typeof raw.title === 'string' ? raw.title : undefined,
+    phaseLabel: typeof raw.phaseLabel === 'string' ? raw.phaseLabel : undefined,
+  }
+}
+
+/**
+ * Handle the completion signal from a client-executable tool.
+ * Shared by both main and subagent scopes.
+ */
+export function handleClientCompletion(
+  toolCall: ToolCallState,
+  toolCallId: string,
+  completion: AsyncTerminalCompletionSnapshot | null
+): void {
+  if (completion?.status === ASYNC_TOOL_CONFIRMATION_STATUS.background) {
+    setTerminalToolCallState(toolCall, {
+      status: MothershipStreamV1ToolOutcome.skipped,
+      ...(completion.data !== undefined ? { output: completion.data } : {}),
+    })
+    markToolResultSeen(toolCallId)
+    return
+  }
+  if (completion?.status === MothershipStreamV1ToolOutcome.cancelled) {
+    setTerminalToolCallState(toolCall, {
+      status: MothershipStreamV1ToolOutcome.cancelled,
+      ...(completion.data !== undefined ? { output: completion.data } : {}),
+      error: completion.message || 'Tool cancelled',
+    })
+    markToolResultSeen(toolCallId)
+    return
+  }
+  const success = completion?.status === MothershipStreamV1ToolOutcome.success
+  setTerminalToolCallState(toolCall, {
+    status: success ? MothershipStreamV1ToolOutcome.success : MothershipStreamV1ToolOutcome.error,
+    ...(completion?.data !== undefined ? { output: completion.data } : {}),
+    ...(success ? {} : { error: completion?.message || 'Tool failed' }),
+  })
+  markToolResultSeen(toolCallId)
+}
+
+/**
+ * Emit a synthetic tool_result SSE event to the client after a client-executable
+ * tool completes. The Go backend's actual tool_result is skipped (markToolResultSeen),
+ * so the client would never learn the outcome without this.
+ */
+export async function emitSyntheticToolResult(
+  toolCallId: string,
+  toolName: string,
+  completion: AsyncTerminalCompletionSnapshot | null,
+  options: OrchestratorOptions
+): Promise<void> {
+  const isBackground = completion?.status === ASYNC_TOOL_CONFIRMATION_STATUS.background
+  const success = isBackground || completion?.status === MothershipStreamV1ToolOutcome.success
+  const isCancelled = completion?.status === MothershipStreamV1ToolOutcome.cancelled
+  const completionData = completion?.data
+  const syntheticStatus = isBackground
+    ? MothershipStreamV1ToolOutcome.skipped
+    : completion?.status === MothershipStreamV1ToolOutcome.success ||
+        completion?.status === MothershipStreamV1ToolOutcome.error ||
+        completion?.status === MothershipStreamV1ToolOutcome.cancelled
+      ? completion.status
+      : undefined
+
+  const resultPayload = isCancelled
+    ? isRecord(completionData)
+      ? { ...completionData, reason: 'user_cancelled', cancelledByUser: true }
+      : completionData !== undefined
+        ? { output: completionData, reason: 'user_cancelled', cancelledByUser: true }
+        : { reason: 'user_cancelled', cancelledByUser: true }
+    : completionData
+
+  try {
+    await options.onEvent?.({
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId,
+        toolName,
+        executor: MothershipStreamV1ToolExecutor.client,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.result,
+        success,
+        output: resultPayload,
+        ...(syntheticStatus ? { status: syntheticStatus } : {}),
+        ...(!success && completion?.message ? { error: completion.message } : {}),
+      },
+    })
+  } catch (error) {
+    logger.warn('Failed to emit synthetic tool_result', {
+      toolCallId,
+      toolName,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+export function getToolResultErrorMessage(
+  data: MothershipStreamV1ToolResultPayload | undefined
+): string | undefined {
+  return data?.error
+}
+
+export function inferToolSuccess(data: MothershipStreamV1ToolResultPayload | undefined): {
+  success: boolean
+  hasResultData: boolean
+  hasError: boolean
+} {
+  const errorMessage = getToolResultErrorMessage(data)
+  const hasResultData = data?.output !== undefined
+  const hasError = Boolean(errorMessage)
+  const success = data?.success === true
+  return { success, hasResultData, hasError }
+}
+
+export function ensureTerminalToolCallState(
+  context: StreamingContext,
+  toolCallId: string,
+  toolName: string
+): ToolCallState {
+  const existing = context.toolCalls.get(toolCallId)
+  if (existing) {
+    return existing
+  }
+
+  const toolCall: ToolCallState = {
+    id: toolCallId,
+    name: toolName || 'unknown_tool',
+    status: 'pending',
+    startTime: Date.now(),
+  }
+  context.toolCalls.set(toolCallId, toolCall)
+  addContentBlock(context, { type: 'tool_call', toolCall })
+  return toolCall
+}
diff --git a/apps/sim/lib/copilot/request-helpers.ts b/apps/sim/lib/copilot/request/http.ts
similarity index 64%
rename from apps/sim/lib/copilot/request-helpers.ts
rename to apps/sim/lib/copilot/request/http.ts
index 0e7be51df41..34eb28cf76a 100644
--- a/apps/sim/lib/copilot/request-helpers.ts
+++ b/apps/sim/lib/copilot/request/http.ts
@@ -1,9 +1,17 @@
+import type { NextRequest } from 'next/server'
 import { NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
+import { ASYNC_TOOL_CONFIRMATION_STATUS } from '@/lib/copilot/async-runs/lifecycle'
+import { env } from '@/lib/core/config/env'
+import { safeCompare } from '@/lib/core/security/encryption'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { generateId } from '@/lib/core/utils/uuid'
 
-export type { NotificationStatus } from '@/lib/copilot/types'
+export const NotificationStatus = {
+  pending: 'pending',
+  ...ASYNC_TOOL_CONFIRMATION_STATUS,
+} as const
+export type NotificationStatus = (typeof NotificationStatus)[keyof typeof NotificationStatus]
 
 export interface CopilotAuthResult {
   userId: string | null
@@ -62,3 +70,22 @@ export async function authenticateCopilotRequestSessionOnly(): Promise<CopilotAu
     isAuthenticated: userId !== null,
   }
 }
+
+export function checkInternalApiKey(req: NextRequest) {
+  const apiKey = req.headers.get('x-api-key')
+  const expectedApiKey = env.INTERNAL_API_SECRET
+
+  if (!expectedApiKey) {
+    return { success: false, error: 'Internal API key not configured' }
+  }
+
+  if (!apiKey) {
+    return { success: false, error: 'API key required' }
+  }
+
+  if (!safeCompare(apiKey, expectedApiKey)) {
+    return { success: false, error: 'Invalid API key' }
+  }
+
+  return { success: true }
+}
diff --git a/apps/sim/lib/copilot/request/lifecycle/finalize.ts b/apps/sim/lib/copilot/request/lifecycle/finalize.ts
new file mode 100644
index 00000000000..676fa7bd176
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/finalize.ts
@@ -0,0 +1,133 @@
+import { createLogger } from '@sim/logger'
+import { updateRunStatus } from '@/lib/copilot/async-runs/repository'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamWriter } from '@/lib/copilot/request/session'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+
+const logger = createLogger('CopilotStreamFinalize')
+
+/**
+ * Single finalization path for stream results.
+ * Handles abort / error / success and publishes the terminal event.
+ * Replaces duplicated blocks in the old chat-streaming.ts.
+ */
+export async function finalizeStream(
+  result: OrchestratorResult,
+  publisher: StreamWriter,
+  runId: string,
+  aborted: boolean,
+  requestId: string
+): Promise<void> {
+  if (aborted) {
+    return handleAborted(result, publisher, runId, requestId)
+  }
+  if (!result.success) {
+    return handleError(result, publisher, runId, requestId)
+  }
+  return handleSuccess(publisher, runId, requestId)
+}
+
+async function handleAborted(
+  result: OrchestratorResult,
+  publisher: StreamWriter,
+  runId: string,
+  requestId: string
+): Promise<void> {
+  const partialContentLen = result.content?.length ?? 0
+  const toolCallCount = result.toolCalls?.length ?? 0
+  const blockCount = result.contentBlocks?.length ?? 0
+  logger.info(`[${requestId}] Stream aborted by explicit stop`, {
+    partialContentLen,
+    toolCallCount,
+    blockCount,
+  })
+  if (!publisher.sawComplete) {
+    const partialContent = result.content || undefined
+    await publisher.publish({
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: MothershipStreamV1CompletionStatus.cancelled,
+        ...(partialContent ? { partialContent } : {}),
+        ...(partialContentLen ? { partialContentLen } : {}),
+        ...(toolCallCount ? { toolCallCount } : {}),
+      },
+    })
+  }
+  await publisher.flush()
+  await loggedRunStatusUpdate(runId, MothershipStreamV1CompletionStatus.cancelled, requestId, {
+    completedAt: new Date(),
+  })
+}
+
+async function handleError(
+  result: OrchestratorResult,
+  publisher: StreamWriter,
+  runId: string,
+  requestId: string
+): Promise<void> {
+  const errorMessage =
+    result.error ||
+    result.errors?.[0] ||
+    'An unexpected error occurred while processing the response.'
+
+  if (publisher.clientDisconnected) {
+    logger.info(`[${requestId}] Stream failed after client disconnect`, { error: errorMessage })
+  }
+  logger.error(`[${requestId}] Orchestration returned failure`, { error: errorMessage })
+
+  await publisher.publish({
+    type: MothershipStreamV1EventType.error,
+    payload: {
+      message: errorMessage,
+      error: errorMessage,
+      data: { displayMessage: 'An unexpected error occurred while processing the response.' },
+    },
+  })
+  if (!publisher.sawComplete) {
+    await publisher.publish({
+      type: MothershipStreamV1EventType.complete,
+      payload: { status: MothershipStreamV1CompletionStatus.error },
+    })
+  }
+  await publisher.flush()
+  await loggedRunStatusUpdate(runId, MothershipStreamV1CompletionStatus.error, requestId, {
+    completedAt: new Date(),
+    error: errorMessage,
+  })
+}
+
+async function handleSuccess(
+  publisher: StreamWriter,
+  runId: string,
+  requestId: string
+): Promise<void> {
+  if (!publisher.sawComplete) {
+    await publisher.publish({
+      type: MothershipStreamV1EventType.complete,
+      payload: { status: MothershipStreamV1CompletionStatus.complete },
+    })
+  }
+  await publisher.flush()
+  await loggedRunStatusUpdate(runId, MothershipStreamV1CompletionStatus.complete, requestId, {
+    completedAt: new Date(),
+  })
+}
+
+async function loggedRunStatusUpdate(
+  runId: string,
+  status: Parameters<typeof updateRunStatus>[1],
+  requestId: string,
+  updates: Parameters<typeof updateRunStatus>[2] = {}
+): Promise<void> {
+  try {
+    await updateRunStatus(runId, status, updates)
+  } catch (error) {
+    logger.warn(`[${requestId}] Failed to update run status to ${status}`, {
+      runId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/lifecycle/headless.test.ts b/apps/sim/lib/copilot/request/lifecycle/headless.test.ts
new file mode 100644
index 00000000000..10b8f656689
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/headless.test.ts
@@ -0,0 +1,181 @@
+/**
+ * @vitest-environment node
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { RequestTraceV1Outcome } from '@/lib/copilot/generated/request-trace-v1'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+
+const { runCopilotLifecycle } = vi.hoisted(() => ({
+  runCopilotLifecycle: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/lifecycle/run', () => ({
+  runCopilotLifecycle,
+}))
+
+import { runHeadlessCopilotLifecycle } from './headless'
+
+function createLifecycleResult(overrides?: Partial<OrchestratorResult>): OrchestratorResult {
+  return {
+    success: true,
+    content: 'done',
+    contentBlocks: [],
+    toolCalls: [],
+    chatId: 'chat-1',
+    ...overrides,
+  }
+}
+
+describe('runHeadlessCopilotLifecycle', () => {
+  beforeEach(() => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue(
+        new Response(null, {
+          status: 200,
+        })
+      )
+    )
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+    vi.unstubAllGlobals()
+  })
+
+  it('reports a successful headless trace', async () => {
+    runCopilotLifecycle.mockResolvedValueOnce(
+      createLifecycleResult({
+        usage: { prompt: 10, completion: 5 },
+        cost: { input: 1, output: 2, total: 3 },
+      })
+    )
+
+    const result = await runHeadlessCopilotLifecycle(
+      {
+        message: 'hello',
+        messageId: 'req-1',
+      },
+      {
+        userId: 'user-1',
+        chatId: 'chat-1',
+        workflowId: 'workflow-1',
+        goRoute: '/api/mothership/execute',
+        interactive: false,
+      }
+    )
+
+    expect(result.success).toBe(true)
+    expect(runCopilotLifecycle).toHaveBeenCalledWith(
+      expect.objectContaining({ messageId: 'req-1' }),
+      expect.objectContaining({
+        simRequestId: 'req-1',
+        trace: expect.any(Object),
+        chatId: 'chat-1',
+      })
+    )
+
+    expect(fetch).toHaveBeenCalledTimes(1)
+    const [url, init] = vi.mocked(fetch).mock.calls[0] as [string, RequestInit]
+    expect(url).toContain('/api/traces')
+    const body = JSON.parse(String(init.body))
+    expect(body).toEqual(
+      expect.objectContaining({
+        simRequestId: 'req-1',
+        outcome: RequestTraceV1Outcome.success,
+        chatId: 'chat-1',
+        usage: {
+          inputTokens: 10,
+          outputTokens: 5,
+        },
+        cost: {
+          rawTotalCost: 3,
+          billedTotalCost: 3,
+        },
+      })
+    )
+  })
+
+  it('reports an error trace when the lifecycle result is unsuccessful', async () => {
+    runCopilotLifecycle.mockResolvedValueOnce(
+      createLifecycleResult({
+        success: false,
+        error: 'failed',
+      })
+    )
+
+    const result = await runHeadlessCopilotLifecycle(
+      {
+        message: 'hello',
+        messageId: 'req-2',
+      },
+      {
+        userId: 'user-1',
+        chatId: 'chat-1',
+        workflowId: 'workflow-1',
+        goRoute: '/api/mothership/execute',
+        interactive: false,
+      }
+    )
+
+    expect(result.success).toBe(false)
+    const [, init] = vi.mocked(fetch).mock.calls[0] as [string, RequestInit]
+    const body = JSON.parse(String(init.body))
+    expect(body.outcome).toBe(RequestTraceV1Outcome.error)
+  })
+
+  it('prefers an explicit simRequestId over the payload messageId', async () => {
+    runCopilotLifecycle.mockResolvedValueOnce(createLifecycleResult())
+
+    await runHeadlessCopilotLifecycle(
+      {
+        message: 'hello',
+        messageId: 'message-req-id',
+      },
+      {
+        userId: 'user-1',
+        chatId: 'chat-1',
+        workflowId: 'workflow-1',
+        simRequestId: 'workflow-request-id',
+        goRoute: '/api/mothership/execute',
+        interactive: false,
+      }
+    )
+
+    expect(runCopilotLifecycle).toHaveBeenCalledWith(
+      expect.objectContaining({ messageId: 'message-req-id' }),
+      expect.objectContaining({
+        simRequestId: 'workflow-request-id',
+      })
+    )
+
+    const [, init] = vi.mocked(fetch).mock.calls[0] as [string, RequestInit]
+    const body = JSON.parse(String(init.body))
+    expect(body.simRequestId).toBe('workflow-request-id')
+  })
+
+  it('reports an error trace when the lifecycle throws', async () => {
+    runCopilotLifecycle.mockRejectedValueOnce(new Error('kaboom'))
+
+    await expect(
+      runHeadlessCopilotLifecycle(
+        {
+          message: 'hello',
+          messageId: 'req-3',
+        },
+        {
+          userId: 'user-1',
+          chatId: 'chat-1',
+          workflowId: 'workflow-1',
+          goRoute: '/api/mothership/execute',
+          interactive: false,
+        }
+      )
+    ).rejects.toThrow('kaboom')
+
+    const [, init] = vi.mocked(fetch).mock.calls[0] as [string, RequestInit]
+    const body = JSON.parse(String(init.body))
+    expect(body.outcome).toBe(RequestTraceV1Outcome.error)
+  })
+})
diff --git a/apps/sim/lib/copilot/request/lifecycle/headless.ts b/apps/sim/lib/copilot/request/lifecycle/headless.ts
new file mode 100644
index 00000000000..d3e3be12aa4
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/headless.ts
@@ -0,0 +1,83 @@
+import { createLogger } from '@sim/logger'
+import type { RequestTraceV1Outcome as RequestTraceOutcome } from '@/lib/copilot/generated/request-trace-v1'
+import {
+  RequestTraceV1Outcome,
+  RequestTraceV1SpanStatus,
+} from '@/lib/copilot/generated/request-trace-v1'
+import type { CopilotLifecycleOptions } from '@/lib/copilot/request/lifecycle/run'
+import { runCopilotLifecycle } from '@/lib/copilot/request/lifecycle/run'
+import { reportTrace, TraceCollector } from '@/lib/copilot/request/trace'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+import { generateId } from '@/lib/core/utils/uuid'
+
+const logger = createLogger('CopilotHeadlessLifecycle')
+
+export async function runHeadlessCopilotLifecycle(
+  requestPayload: Record<string, unknown>,
+  options: CopilotLifecycleOptions
+): Promise<OrchestratorResult> {
+  const simRequestId =
+    typeof options.simRequestId === 'string' && options.simRequestId.length > 0
+      ? options.simRequestId
+      : typeof requestPayload.messageId === 'string' && requestPayload.messageId.length > 0
+        ? requestPayload.messageId
+        : generateId()
+  const trace = new TraceCollector()
+  const requestSpan = trace.startSpan('Headless Mothership Request', 'request', {
+    route: options.goRoute,
+    workflowId: options.workflowId,
+    workspaceId: options.workspaceId,
+    chatId: options.chatId,
+  })
+
+  let result: OrchestratorResult | undefined
+  let outcome: RequestTraceOutcome = RequestTraceV1Outcome.error
+
+  try {
+    result = await runCopilotLifecycle(requestPayload, {
+      ...options,
+      trace,
+      simRequestId,
+    })
+    outcome = options.abortSignal?.aborted
+      ? RequestTraceV1Outcome.cancelled
+      : result.success
+        ? RequestTraceV1Outcome.success
+        : RequestTraceV1Outcome.error
+    return result
+  } catch (error) {
+    outcome = options.abortSignal?.aborted
+      ? RequestTraceV1Outcome.cancelled
+      : RequestTraceV1Outcome.error
+    throw error
+  } finally {
+    trace.endSpan(
+      requestSpan,
+      outcome === RequestTraceV1Outcome.success
+        ? RequestTraceV1SpanStatus.ok
+        : outcome === RequestTraceV1Outcome.cancelled
+          ? RequestTraceV1SpanStatus.cancelled
+          : RequestTraceV1SpanStatus.error
+    )
+
+    try {
+      await reportTrace(
+        trace.build({
+          outcome,
+          simRequestId,
+          chatId: result?.chatId ?? options.chatId,
+          runId: options.runId,
+          executionId: options.executionId,
+          usage: result?.usage,
+          cost: result?.cost,
+        })
+      )
+    } catch (error) {
+      logger.warn('Failed to report headless trace', {
+        simRequestId,
+        chatId: result?.chatId ?? options.chatId,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/lifecycle/run.ts b/apps/sim/lib/copilot/request/lifecycle/run.ts
new file mode 100644
index 00000000000..1156d3b5928
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/run.ts
@@ -0,0 +1,550 @@
+import { createLogger } from '@sim/logger'
+import { createRunSegment, updateRunStatus } from '@/lib/copilot/async-runs/repository'
+import { SIM_AGENT_API_URL, SIM_AGENT_VERSION } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1RunKind,
+  MothershipStreamV1ToolOutcome,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
+import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
+import {
+  BillingLimitError,
+  CopilotBackendError,
+  runStreamLoop,
+} from '@/lib/copilot/request/go/stream'
+import {
+  getToolCallTerminalData,
+  requireToolCallStateResult,
+  setTerminalToolCallState,
+} from '@/lib/copilot/request/tool-call-state'
+import { handleBillingLimitResponse } from '@/lib/copilot/request/tools/billing'
+import { executeToolAndReport } from '@/lib/copilot/request/tools/executor'
+import type { TraceCollector } from '@/lib/copilot/request/trace'
+import { RequestTraceV1SpanStatus } from '@/lib/copilot/request/trace'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  OrchestratorResult,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
+import { env } from '@/lib/core/config/env'
+import { generateId } from '@/lib/core/utils/uuid'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+
+const logger = createLogger('CopilotLifecycle')
+
+const MAX_RESUME_ATTEMPTS = 3
+const RESUME_BACKOFF_MS = [250, 500, 1000] as const
+
+export interface CopilotLifecycleOptions extends OrchestratorOptions {
+  userId: string
+  workflowId?: string
+  workspaceId?: string
+  chatId?: string
+  executionId?: string
+  runId?: string
+  goRoute?: string
+  trace?: TraceCollector
+  simRequestId?: string
+  onGoTraceId?: (goTraceId: string) => void
+  executionContext?: ExecutionContext
+}
+
+export async function runCopilotLifecycle(
+  requestPayload: Record<string, unknown>,
+  options: CopilotLifecycleOptions
+): Promise<OrchestratorResult> {
+  const {
+    userId,
+    workflowId,
+    workspaceId,
+    chatId,
+    executionId,
+    runId,
+    goRoute = '/api/copilot',
+  } = options
+  const payloadMsgId =
+    typeof requestPayload?.messageId === 'string' ? requestPayload.messageId : generateId()
+  const runIdentity = await ensureHeadlessRunIdentity({
+    requestPayload,
+    userId,
+    workflowId,
+    workspaceId,
+    chatId,
+    executionId,
+    runId,
+    messageId: payloadMsgId,
+  })
+  const resolvedExecutionId = runIdentity.executionId ?? executionId
+  const resolvedRunId = runIdentity.runId ?? runId
+  const lifecycleOptions: CopilotLifecycleOptions = {
+    ...options,
+    executionId: resolvedExecutionId,
+    runId: resolvedRunId,
+    ...(options.executionContext
+      ? {
+          executionContext: {
+            ...options.executionContext,
+            messageId: payloadMsgId,
+            executionId: resolvedExecutionId,
+            runId: resolvedRunId,
+            abortSignal: options.abortSignal,
+          },
+        }
+      : {}),
+  }
+
+  const execContext =
+    lifecycleOptions.executionContext ??
+    (await buildExecutionContext(requestPayload, {
+      userId,
+      workflowId,
+      workspaceId,
+      chatId,
+      executionId: resolvedExecutionId,
+      runId: resolvedRunId,
+      abortSignal: lifecycleOptions.abortSignal,
+    }))
+
+  const context = createStreamingContext({
+    chatId,
+    executionId: resolvedExecutionId,
+    runId: resolvedRunId,
+    messageId: payloadMsgId,
+    ...(lifecycleOptions.trace ? { trace: lifecycleOptions.trace } : {}),
+  })
+
+  try {
+    await runCheckpointLoop(requestPayload, context, execContext, lifecycleOptions, goRoute)
+
+    const result: OrchestratorResult = {
+      success: context.errors.length === 0 && !context.wasAborted,
+      content: context.accumulatedContent,
+      contentBlocks: context.contentBlocks,
+      toolCalls: buildToolCallSummaries(context),
+      chatId: context.chatId,
+      requestId: context.requestId,
+      errors: context.errors.length ? context.errors : undefined,
+      usage: context.usage,
+      cost: context.cost,
+    }
+    await lifecycleOptions.onComplete?.(result)
+    return result
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error('Copilot orchestration failed')
+    logger.error('Copilot orchestration failed', { error: err.message })
+    await lifecycleOptions.onError?.(err)
+    return {
+      success: false,
+      content: '',
+      contentBlocks: [],
+      toolCalls: [],
+      chatId: context.chatId,
+      error: err.message,
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Checkpoint loop – the core state machine
+// ---------------------------------------------------------------------------
+
+async function runCheckpointLoop(
+  initialPayload: Record<string, unknown>,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: CopilotLifecycleOptions,
+  initialRoute: string
+): Promise<void> {
+  let route = initialRoute
+  let payload: Record<string, unknown> = initialPayload
+  let resumeAttempt = 0
+  const callerOnEvent = options.onEvent
+
+  for (;;) {
+    context.streamComplete = false
+    const isResume = route === '/api/tools/resume'
+
+    if (isResume && isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    const loopOptions = {
+      ...options,
+      onEvent: async (event: StreamEvent) => {
+        if (
+          event.type === MothershipStreamV1EventType.run &&
+          event.payload.kind === MothershipStreamV1RunKind.checkpoint_pause &&
+          options.runId
+        ) {
+          try {
+            await updateRunStatus(options.runId, 'paused_waiting_for_tool')
+          } catch (error) {
+            logger.warn('Failed to mark run as paused_waiting_for_tool', {
+              runId: options.runId,
+              error: error instanceof Error ? error.message : String(error),
+            })
+          }
+        }
+        await callerOnEvent?.(event)
+      },
+    }
+
+    const streamSpan = context.trace.startSpan(
+      isResume ? 'Sim → Go (Resume)' : 'Sim → Go Stream',
+      isResume ? 'lifecycle.resume' : 'sim.stream',
+      {
+        route,
+        isResume,
+        ...(isResume ? { attempt: resumeAttempt } : {}),
+      }
+    )
+    context.trace.setActiveSpan(streamSpan)
+
+    logger.info('Starting stream loop', {
+      route,
+      isResume,
+      resumeAttempt,
+      pendingToolPromises: context.pendingToolPromises.size,
+      toolCallCount: context.toolCalls.size,
+      hasCheckpoint: !!context.awaitingAsyncContinuation,
+    })
+
+    try {
+      await runStreamLoop(
+        `${SIM_AGENT_API_URL}${route}`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+            'X-Client-Version': SIM_AGENT_VERSION,
+            ...(options.simRequestId ? { 'X-Sim-Request-ID': options.simRequestId } : {}),
+          },
+          body: JSON.stringify(payload),
+        },
+        context,
+        execContext,
+        loopOptions
+      )
+      const streamStatus = isAborted(options, context)
+        ? RequestTraceV1SpanStatus.cancelled
+        : context.errors.length > 0
+          ? RequestTraceV1SpanStatus.error
+          : RequestTraceV1SpanStatus.ok
+      context.trace.endSpan(streamSpan, streamStatus)
+      context.trace.setActiveSpan(undefined)
+      resumeAttempt = 0
+    } catch (streamError) {
+      context.trace.endSpan(streamSpan, RequestTraceV1SpanStatus.error)
+      context.trace.setActiveSpan(undefined)
+      if (streamError instanceof BillingLimitError) {
+        await handleBillingLimitResponse(streamError.userId, context, execContext, options)
+        break
+      }
+      if (
+        isResume &&
+        isRetryableStreamError(streamError) &&
+        resumeAttempt < MAX_RESUME_ATTEMPTS - 1
+      ) {
+        resumeAttempt++
+        const backoff = RESUME_BACKOFF_MS[resumeAttempt - 1] ?? 1000
+        logger.warn('Resume stream failed, retrying', {
+          attempt: resumeAttempt + 1,
+          maxAttempts: MAX_RESUME_ATTEMPTS,
+          backoffMs: backoff,
+          error: streamError instanceof Error ? streamError.message : String(streamError),
+        })
+        await sleepWithAbort(backoff, options.abortSignal)
+        continue
+      }
+      throw streamError
+    }
+
+    logger.info('Stream loop completed', {
+      route,
+      isResume,
+      isAborted: isAborted(options, context),
+      hasCheckpoint: !!context.awaitingAsyncContinuation,
+      checkpointId: context.awaitingAsyncContinuation?.checkpointId,
+      pendingToolPromises: context.pendingToolPromises.size,
+      streamComplete: context.streamComplete,
+      toolCallCount: context.toolCalls.size,
+    })
+
+    if (isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    const continuation = context.awaitingAsyncContinuation
+    if (!continuation) break
+
+    if (context.pendingToolPromises.size > 0) {
+      const waitSpan = context.trace.startSpan('Wait for Tools', 'lifecycle.wait_tools', {
+        checkpointId: continuation.checkpointId,
+        pendingCount: context.pendingToolPromises.size,
+      })
+      logger.info('Waiting for in-flight tool executions before resume', {
+        checkpointId: continuation.checkpointId,
+        pendingCount: context.pendingToolPromises.size,
+      })
+      await Promise.allSettled(context.pendingToolPromises.values())
+      context.trace.endSpan(waitSpan)
+    }
+
+    if (isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    const undispatchedToolIds = continuation.pendingToolCallIds.filter((toolCallId) => {
+      const tool = context.toolCalls.get(toolCallId)
+      return (
+        !!tool &&
+        !tool.result &&
+        !tool.error &&
+        !context.pendingToolPromises.has(toolCallId) &&
+        tool.status !== 'executing'
+      )
+    })
+
+    if (undispatchedToolIds.length > 0) {
+      logger.warn('Checkpointed tools were never dispatched; executing before resume', {
+        checkpointId: continuation.checkpointId,
+        toolCallIds: undispatchedToolIds,
+      })
+      await Promise.allSettled(
+        undispatchedToolIds.map((toolCallId) =>
+          executeToolAndReport(toolCallId, context, execContext, options)
+        )
+      )
+    }
+
+    if (isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    const results: Array<{
+      callId: string
+      name: string
+      data: unknown
+      success: boolean
+    }> = []
+    for (const toolCallId of continuation.pendingToolCallIds) {
+      if (isAborted(options, context)) {
+        cancelPendingTools(context)
+        context.awaitingAsyncContinuation = undefined
+        break
+      }
+      const tool = context.toolCalls.get(toolCallId)
+      if (!tool || !tool.result) {
+        logger.error('Missing tool result for pending tool call', {
+          toolCallId,
+          checkpointId: continuation.checkpointId,
+          hasToolEntry: !!tool,
+          toolName: tool?.name,
+          toolStatus: tool?.status,
+          hasPendingPromise: context.pendingToolPromises.has(toolCallId),
+        })
+        throw new Error(`Cannot resume: missing result for pending tool call ${toolCallId}`)
+      }
+      results.push({
+        callId: toolCallId,
+        name: tool.name || '',
+        data: getToolCallTerminalData(tool),
+        success: requireToolCallStateResult(tool).success,
+      })
+    }
+
+    if (isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    logger.info('Resuming with tool results', {
+      checkpointId: continuation.checkpointId,
+      runId: continuation.runId,
+      toolCount: results.length,
+      pendingToolCallIds: continuation.pendingToolCallIds,
+      frameCount: continuation.frames?.length ?? 0,
+    })
+
+    context.awaitingAsyncContinuation = undefined
+    route = '/api/tools/resume'
+    payload = {
+      streamId: context.messageId,
+      checkpointId: continuation.checkpointId,
+      results,
+    }
+
+    if (isAborted(options, context)) {
+      cancelPendingTools(context)
+      context.awaitingAsyncContinuation = undefined
+      break
+    }
+
+    logger.info('Prepared resume request payload', {
+      route,
+      streamId: context.messageId,
+      checkpointId: continuation.checkpointId,
+      resultCount: results.length,
+    })
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Execution context builder
+// ---------------------------------------------------------------------------
+
+async function buildExecutionContext(
+  requestPayload: Record<string, unknown>,
+  params: {
+    userId: string
+    workflowId?: string
+    workspaceId?: string
+    chatId?: string
+    executionId?: string
+    runId?: string
+    abortSignal?: AbortSignal
+  }
+): Promise<ExecutionContext> {
+  const { userId, workflowId, workspaceId, chatId, executionId, runId, abortSignal } = params
+  const userTimezone =
+    typeof requestPayload?.userTimezone === 'string' ? requestPayload.userTimezone : undefined
+  const requestMode = typeof requestPayload?.mode === 'string' ? requestPayload.mode : undefined
+
+  let execContext: ExecutionContext
+  if (workflowId) {
+    execContext = await prepareExecutionContext(userId, workflowId, chatId)
+  } else {
+    const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
+    execContext = {
+      userId,
+      workflowId: '',
+      workspaceId,
+      chatId,
+      decryptedEnvVars,
+    }
+  }
+
+  if (userTimezone) execContext.userTimezone = userTimezone
+  execContext.copilotToolExecution = true
+  if (requestMode) execContext.requestMode = requestMode
+  execContext.messageId =
+    typeof requestPayload?.messageId === 'string' ? requestPayload.messageId : undefined
+  execContext.executionId = executionId
+  execContext.runId = runId
+  execContext.abortSignal = abortSignal
+  return execContext
+}
+
+async function ensureHeadlessRunIdentity(input: {
+  requestPayload: Record<string, unknown>
+  userId: string
+  workflowId?: string
+  workspaceId?: string
+  chatId?: string
+  executionId?: string
+  runId?: string
+  messageId: string
+}): Promise<{ executionId?: string; runId?: string }> {
+  if (!input.chatId || input.executionId || input.runId) {
+    return {
+      executionId: input.executionId,
+      runId: input.runId,
+    }
+  }
+
+  const executionId = generateId()
+  const runId = generateId()
+
+  try {
+    await createRunSegment({
+      id: runId,
+      executionId,
+      chatId: input.chatId,
+      userId: input.userId,
+      workflowId: input.workflowId,
+      workspaceId: input.workspaceId,
+      streamId: input.messageId,
+      model: typeof input.requestPayload?.model === 'string' ? input.requestPayload.model : null,
+      provider:
+        typeof input.requestPayload?.provider === 'string' ? input.requestPayload.provider : null,
+      requestContext: {
+        source: 'headless_lifecycle',
+      },
+    })
+    return { executionId, runId }
+  } catch (error) {
+    logger.warn('Failed to create headless run identity', {
+      chatId: input.chatId,
+      messageId: input.messageId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return {}
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function isAborted(options: CopilotLifecycleOptions, context: StreamingContext): boolean {
+  return !!(options.abortSignal?.aborted || context.wasAborted)
+}
+
+function cancelPendingTools(context: StreamingContext): void {
+  for (const [, toolCall] of context.toolCalls) {
+    if (toolCall.status === 'pending' || toolCall.status === 'executing') {
+      setTerminalToolCallState(toolCall, {
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        error: 'Stopped by user',
+      })
+    }
+  }
+}
+
+function isRetryableStreamError(error: unknown): boolean {
+  if (error instanceof DOMException && error.name === 'AbortError') {
+    return false
+  }
+  if (error instanceof CopilotBackendError) {
+    return error.status !== undefined && error.status >= 500
+  }
+  if (error instanceof TypeError) {
+    return true
+  }
+  return false
+}
+
+function sleepWithAbort(ms: number, abortSignal?: AbortSignal): Promise<void> {
+  if (!abortSignal) {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+  if (abortSignal.aborted) {
+    return Promise.resolve()
+  }
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => {
+      abortSignal.removeEventListener('abort', onAbort)
+      resolve()
+    }, ms)
+    const onAbort = () => {
+      clearTimeout(timeoutId)
+      abortSignal.removeEventListener('abort', onAbort)
+      resolve()
+    }
+    abortSignal.addEventListener('abort', onAbort, { once: true })
+  })
+}
diff --git a/apps/sim/lib/copilot/request/lifecycle/start.test.ts b/apps/sim/lib/copilot/request/lifecycle/start.test.ts
new file mode 100644
index 00000000000..9c5ee7adacf
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/start.test.ts
@@ -0,0 +1,193 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+
+const {
+  runCopilotLifecycle,
+  createRunSegment,
+  updateRunStatus,
+  resetBuffer,
+  clearFilePreviewSessions,
+  scheduleBufferCleanup,
+  scheduleFilePreviewSessionCleanup,
+  allocateCursor,
+  appendEvent,
+  cleanupAbortMarker,
+  hasAbortMarker,
+  releasePendingChatStream,
+} = vi.hoisted(() => ({
+  runCopilotLifecycle: vi.fn(),
+  createRunSegment: vi.fn(),
+  updateRunStatus: vi.fn(),
+  resetBuffer: vi.fn(),
+  clearFilePreviewSessions: vi.fn(),
+  scheduleBufferCleanup: vi.fn(),
+  scheduleFilePreviewSessionCleanup: vi.fn(),
+  allocateCursor: vi.fn(),
+  appendEvent: vi.fn(),
+  cleanupAbortMarker: vi.fn(),
+  hasAbortMarker: vi.fn(),
+  releasePendingChatStream: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/lifecycle/run', () => ({
+  runCopilotLifecycle,
+}))
+
+vi.mock('@/lib/copilot/async-runs/repository', () => ({
+  createRunSegment,
+  updateRunStatus,
+}))
+
+let mockPublisherController: ReadableStreamDefaultController | null = null
+
+vi.mock('@/lib/copilot/request/session', () => ({
+  resetBuffer,
+  clearFilePreviewSessions,
+  scheduleBufferCleanup,
+  scheduleFilePreviewSessionCleanup,
+  allocateCursor,
+  appendEvent,
+  cleanupAbortMarker,
+  hasAbortMarker,
+  releasePendingChatStream,
+  registerActiveStream: vi.fn(),
+  unregisterActiveStream: vi.fn(),
+  startAbortPoller: vi.fn().mockReturnValue(setInterval(() => {}, 999999)),
+  SSE_RESPONSE_HEADERS: {},
+  StreamWriter: vi.fn().mockImplementation(() => ({
+    attach: vi.fn().mockImplementation((ctrl: ReadableStreamDefaultController) => {
+      mockPublisherController = ctrl
+    }),
+    startKeepalive: vi.fn(),
+    stopKeepalive: vi.fn(),
+    flush: vi.fn(),
+    close: vi.fn().mockImplementation(() => {
+      try {
+        mockPublisherController?.close()
+      } catch {
+        // already closed
+      }
+    }),
+    markDisconnected: vi.fn(),
+    publish: vi.fn().mockImplementation(async (event: Record<string, unknown>) => {
+      appendEvent(event)
+    }),
+    get clientDisconnected() {
+      return false
+    },
+    get sawComplete() {
+      return false
+    },
+  })),
+}))
+vi.mock('@/lib/copilot/request/session/sse', () => ({
+  SSE_RESPONSE_HEADERS: {},
+}))
+
+vi.mock('@sim/db', () => ({
+  db: {
+    update: vi.fn(() => ({
+      set: vi.fn(() => ({
+        where: vi.fn(),
+      })),
+    })),
+  },
+}))
+
+vi.mock('@/lib/copilot/tasks', () => ({
+  taskPubSub: null,
+}))
+
+import { createSSEStream } from './start'
+
+async function drainStream(stream: ReadableStream) {
+  const reader = stream.getReader()
+  while (true) {
+    const { done } = await reader.read()
+    if (done) break
+  }
+}
+
+describe('createSSEStream terminal error handling', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetBuffer.mockResolvedValue(undefined)
+    clearFilePreviewSessions.mockResolvedValue(undefined)
+    scheduleBufferCleanup.mockResolvedValue(undefined)
+    scheduleFilePreviewSessionCleanup.mockResolvedValue(undefined)
+    allocateCursor
+      .mockResolvedValueOnce({ seq: 1, cursor: '1' })
+      .mockResolvedValueOnce({ seq: 2, cursor: '2' })
+      .mockResolvedValueOnce({ seq: 3, cursor: '3' })
+    appendEvent.mockImplementation(async (event: unknown) => event)
+    cleanupAbortMarker.mockResolvedValue(undefined)
+    hasAbortMarker.mockResolvedValue(false)
+    releasePendingChatStream.mockResolvedValue(undefined)
+    createRunSegment.mockResolvedValue(null)
+    updateRunStatus.mockResolvedValue(null)
+  })
+
+  it('writes a terminal error event before close when orchestration returns success=false', async () => {
+    runCopilotLifecycle.mockResolvedValue({
+      success: false,
+      error: 'resume failed',
+      content: '',
+      contentBlocks: [],
+      toolCalls: [],
+    })
+
+    const stream = createSSEStream({
+      requestPayload: { message: 'hello' },
+      userId: 'user-1',
+      streamId: 'stream-1',
+      executionId: 'exec-1',
+      runId: 'run-1',
+      currentChat: null,
+      isNewChat: false,
+      message: 'hello',
+      titleModel: 'gpt-5.4',
+      requestId: 'req-1',
+      orchestrateOptions: {},
+    })
+
+    await drainStream(stream)
+
+    expect(appendEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.error,
+      })
+    )
+    expect(scheduleBufferCleanup).toHaveBeenCalledWith('stream-1')
+  })
+
+  it('writes the thrown terminal error event before close for replay durability', async () => {
+    runCopilotLifecycle.mockRejectedValue(new Error('kaboom'))
+
+    const stream = createSSEStream({
+      requestPayload: { message: 'hello' },
+      userId: 'user-1',
+      streamId: 'stream-1',
+      executionId: 'exec-1',
+      runId: 'run-1',
+      currentChat: null,
+      isNewChat: false,
+      message: 'hello',
+      titleModel: 'gpt-5.4',
+      requestId: 'req-1',
+      orchestrateOptions: {},
+    })
+
+    await drainStream(stream)
+
+    expect(appendEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.error,
+      })
+    )
+    expect(scheduleBufferCleanup).toHaveBeenCalledWith('stream-1')
+  })
+})
diff --git a/apps/sim/lib/copilot/request/lifecycle/start.ts b/apps/sim/lib/copilot/request/lifecycle/start.ts
new file mode 100644
index 00000000000..caf6fb4df87
--- /dev/null
+++ b/apps/sim/lib/copilot/request/lifecycle/start.ts
@@ -0,0 +1,319 @@
+import { db } from '@sim/db'
+import { copilotChats } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
+import { createRunSegment } from '@/lib/copilot/async-runs/repository'
+import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1SessionKind,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { RequestTraceV1Outcome } from '@/lib/copilot/generated/request-trace-v1'
+import { finalizeStream } from '@/lib/copilot/request/lifecycle/finalize'
+import type { CopilotLifecycleOptions } from '@/lib/copilot/request/lifecycle/run'
+import { runCopilotLifecycle } from '@/lib/copilot/request/lifecycle/run'
+import {
+  cleanupAbortMarker,
+  clearFilePreviewSessions,
+  registerActiveStream,
+  releasePendingChatStream,
+  resetBuffer,
+  StreamWriter,
+  scheduleBufferCleanup,
+  scheduleFilePreviewSessionCleanup,
+  startAbortPoller,
+  unregisterActiveStream,
+} from '@/lib/copilot/request/session'
+import { SSE_RESPONSE_HEADERS } from '@/lib/copilot/request/session/sse'
+import { reportTrace, TraceCollector } from '@/lib/copilot/request/trace'
+import { taskPubSub } from '@/lib/copilot/tasks'
+import { env } from '@/lib/core/config/env'
+
+export { SSE_RESPONSE_HEADERS }
+
+const logger = createLogger('CopilotChatStreaming')
+
+type CurrentChatSummary = {
+  title?: string | null
+} | null
+
+export interface StreamingOrchestrationParams {
+  requestPayload: Record<string, unknown>
+  userId: string
+  streamId: string
+  executionId: string
+  runId: string
+  chatId?: string
+  currentChat: CurrentChatSummary
+  isNewChat: boolean
+  message: string
+  titleModel: string
+  titleProvider?: string
+  requestId: string
+  workspaceId?: string
+  orchestrateOptions: Omit<CopilotLifecycleOptions, 'onEvent'>
+}
+
+export function createSSEStream(params: StreamingOrchestrationParams): ReadableStream {
+  const {
+    requestPayload,
+    userId,
+    streamId,
+    executionId,
+    runId,
+    chatId,
+    currentChat,
+    isNewChat,
+    message,
+    titleModel,
+    titleProvider,
+    requestId,
+    workspaceId,
+    orchestrateOptions,
+  } = params
+
+  const abortController = new AbortController()
+  registerActiveStream(streamId, abortController)
+
+  const publisher = new StreamWriter({ streamId, chatId, requestId })
+
+  const collector = new TraceCollector()
+
+  return new ReadableStream({
+    async start(controller) {
+      publisher.attach(controller)
+
+      const requestSpan = collector.startSpan('Mothership Request', 'request', {
+        streamId,
+        chatId,
+        runId,
+      })
+      let outcome: 'success' | 'error' | 'cancelled' = 'error'
+      let lifecycleResult:
+        | {
+            usage?: { prompt: number; completion: number }
+            cost?: { input: number; output: number; total: number }
+          }
+        | undefined
+
+      await Promise.all([resetBuffer(streamId), clearFilePreviewSessions(streamId)])
+
+      if (chatId) {
+        createRunSegment({
+          id: runId,
+          executionId,
+          chatId,
+          userId,
+          workflowId: (requestPayload.workflowId as string | undefined) || null,
+          workspaceId,
+          streamId,
+          model: (requestPayload.model as string | undefined) || null,
+          provider: (requestPayload.provider as string | undefined) || null,
+          requestContext: { requestId },
+        }).catch((error) => {
+          logger.warn(`[${requestId}] Failed to create copilot run segment`, {
+            error: error instanceof Error ? error.message : String(error),
+          })
+        })
+      }
+
+      const abortPoller = startAbortPoller(streamId, abortController, { requestId })
+      publisher.startKeepalive()
+
+      if (chatId) {
+        publisher.publish({
+          type: MothershipStreamV1EventType.session,
+          payload: {
+            kind: MothershipStreamV1SessionKind.chat,
+            chatId,
+          },
+        })
+      }
+
+      fireTitleGeneration({
+        chatId,
+        currentChat,
+        isNewChat,
+        message,
+        titleModel,
+        titleProvider,
+        workspaceId,
+        requestId,
+        publisher,
+      })
+
+      try {
+        const result = await runCopilotLifecycle(requestPayload, {
+          ...orchestrateOptions,
+          executionId,
+          runId,
+          trace: collector,
+          simRequestId: requestId,
+          abortSignal: abortController.signal,
+          onEvent: async (event) => {
+            await publisher.publish(event)
+          },
+        })
+
+        lifecycleResult = result
+        outcome = abortController.signal.aborted
+          ? RequestTraceV1Outcome.cancelled
+          : result.success
+            ? RequestTraceV1Outcome.success
+            : RequestTraceV1Outcome.error
+        await finalizeStream(result, publisher, runId, abortController.signal.aborted, requestId)
+      } catch (error) {
+        outcome = abortController.signal.aborted
+          ? RequestTraceV1Outcome.cancelled
+          : RequestTraceV1Outcome.error
+        if (publisher.clientDisconnected) {
+          logger.info(`[${requestId}] Stream errored after client disconnect`, {
+            error: error instanceof Error ? error.message : 'Stream error',
+          })
+        }
+        logger.error(`[${requestId}] Unexpected orchestration error:`, error)
+
+        const syntheticResult = {
+          success: false as const,
+          content: '',
+          contentBlocks: [],
+          toolCalls: [],
+          error: 'An unexpected error occurred while processing the response.',
+        }
+        await finalizeStream(
+          syntheticResult,
+          publisher,
+          runId,
+          abortController.signal.aborted,
+          requestId
+        )
+      } finally {
+        collector.endSpan(
+          requestSpan,
+          outcome === RequestTraceV1Outcome.success
+            ? 'ok'
+            : outcome === RequestTraceV1Outcome.cancelled
+              ? 'cancelled'
+              : 'error'
+        )
+
+        clearInterval(abortPoller)
+        try {
+          await publisher.close()
+        } catch (error) {
+          logger.warn(`[${requestId}] Failed to flush stream persistence during close`, {
+            error: error instanceof Error ? error.message : String(error),
+          })
+        }
+        unregisterActiveStream(streamId)
+        if (chatId) {
+          await releasePendingChatStream(chatId, streamId)
+        }
+        await scheduleBufferCleanup(streamId)
+        await scheduleFilePreviewSessionCleanup(streamId)
+        await cleanupAbortMarker(streamId)
+
+        const trace = collector.build({
+          outcome: outcome as 'success' | 'error' | 'cancelled',
+          simRequestId: requestId,
+          streamId,
+          chatId,
+          runId,
+          executionId,
+          usage: lifecycleResult?.usage,
+          cost: lifecycleResult?.cost,
+        })
+        reportTrace(trace).catch(() => {})
+      }
+    },
+    cancel() {
+      publisher.markDisconnected()
+    },
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Title generation (fire-and-forget side effect)
+// ---------------------------------------------------------------------------
+
+function fireTitleGeneration(params: {
+  chatId?: string
+  currentChat: CurrentChatSummary
+  isNewChat: boolean
+  message: string
+  titleModel: string
+  titleProvider?: string
+  workspaceId?: string
+  requestId: string
+  publisher: StreamWriter
+}): void {
+  const {
+    chatId,
+    currentChat,
+    isNewChat,
+    message,
+    titleModel,
+    titleProvider,
+    workspaceId,
+    requestId,
+    publisher,
+  } = params
+  if (!chatId || currentChat?.title || !isNewChat) return
+
+  requestChatTitle({ message, model: titleModel, provider: titleProvider })
+    .then(async (title) => {
+      if (!title) return
+      await db.update(copilotChats).set({ title }).where(eq(copilotChats.id, chatId))
+      await publisher.publish({
+        type: MothershipStreamV1EventType.session,
+        payload: { kind: MothershipStreamV1SessionKind.title, title },
+      })
+      if (workspaceId) {
+        taskPubSub?.publishStatusChanged({ workspaceId, chatId, type: 'renamed' })
+      }
+    })
+    .catch((error) => {
+      logger.error(`[${requestId}] Title generation failed:`, error)
+    })
+}
+
+// ---------------------------------------------------------------------------
+// Chat title helper
+// ---------------------------------------------------------------------------
+
+export async function requestChatTitle(params: {
+  message: string
+  model: string
+  provider?: string
+}): Promise<string | null> {
+  const { message, model, provider } = params
+  if (!message || !model) return null
+
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+  if (env.COPILOT_API_KEY) {
+    headers['x-api-key'] = env.COPILOT_API_KEY
+  }
+
+  try {
+    const response = await fetch(`${SIM_AGENT_API_URL}/api/generate-chat-title`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ message, model, ...(provider ? { provider } : {}) }),
+    })
+
+    const payload = await response.json().catch(() => ({}))
+    if (!response.ok) {
+      logger.warn('Failed to generate chat title via copilot backend', {
+        status: response.status,
+        error: payload,
+      })
+      return null
+    }
+
+    const title = typeof payload?.title === 'string' ? payload.title.trim() : ''
+    return title || null
+  } catch (error) {
+    logger.error('Error generating chat title:', error)
+    return null
+  }
+}
diff --git a/apps/sim/lib/copilot/request/session/abort.ts b/apps/sim/lib/copilot/request/session/abort.ts
new file mode 100644
index 00000000000..3502f4a69f8
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/abort.ts
@@ -0,0 +1,234 @@
+import { createLogger } from '@sim/logger'
+import { acquireLock, getRedisClient, releaseLock } from '@/lib/core/config/redis'
+import { clearAbortMarker, hasAbortMarker, writeAbortMarker } from './buffer'
+
+const logger = createLogger('SessionAbort')
+
+const activeStreams = new Map<string, AbortController>()
+const pendingChatStreams = new Map<
+  string,
+  { promise: Promise<void>; resolve: () => void; streamId: string }
+>()
+
+const DEFAULT_ABORT_POLL_MS = 1000
+const CHAT_STREAM_LOCK_TTL_SECONDS = 2 * 60 * 60
+
+function registerPendingChatStream(chatId: string, streamId: string): void {
+  let resolve!: () => void
+  const promise = new Promise<void>((r) => {
+    resolve = r
+  })
+  pendingChatStreams.set(chatId, { promise, resolve, streamId })
+}
+
+function resolvePendingChatStream(chatId: string, streamId: string): void {
+  const entry = pendingChatStreams.get(chatId)
+  if (entry && entry.streamId === streamId) {
+    entry.resolve()
+    pendingChatStreams.delete(chatId)
+  }
+}
+
+function getChatStreamLockKey(chatId: string): string {
+  return `copilot:chat-stream-lock:${chatId}`
+}
+
+export function registerActiveStream(streamId: string, controller: AbortController): void {
+  activeStreams.set(streamId, controller)
+}
+
+export function unregisterActiveStream(streamId: string): void {
+  activeStreams.delete(streamId)
+}
+
+export async function waitForPendingChatStream(
+  chatId: string,
+  timeoutMs = 5_000,
+  expectedStreamId?: string
+): Promise<boolean> {
+  const redis = getRedisClient()
+  const deadline = Date.now() + timeoutMs
+
+  for (;;) {
+    const entry = pendingChatStreams.get(chatId)
+    const localPending = !!entry && (!expectedStreamId || entry.streamId === expectedStreamId)
+
+    if (redis) {
+      try {
+        const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
+        const lockReleased =
+          !ownerStreamId || (expectedStreamId !== undefined && ownerStreamId !== expectedStreamId)
+        if (!localPending && lockReleased) {
+          return true
+        }
+      } catch (error) {
+        logger.warn('Failed to inspect chat stream lock while waiting', {
+          chatId,
+          expectedStreamId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    } else if (!localPending) {
+      return true
+    }
+
+    if (Date.now() >= deadline) {
+      return false
+    }
+    await new Promise((resolve) => setTimeout(resolve, 200))
+  }
+}
+
+export async function getPendingChatStreamId(chatId: string): Promise<string | null> {
+  const localEntry = pendingChatStreams.get(chatId)
+  if (localEntry?.streamId) {
+    return localEntry.streamId
+  }
+
+  const redis = getRedisClient()
+  if (!redis) {
+    return null
+  }
+
+  try {
+    return (await redis.get(getChatStreamLockKey(chatId))) || null
+  } catch (error) {
+    logger.warn('Failed to load chat stream lock owner', {
+      chatId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return null
+  }
+}
+
+export async function releasePendingChatStream(chatId: string, streamId: string): Promise<void> {
+  try {
+    await releaseLock(getChatStreamLockKey(chatId), streamId)
+  } catch (error) {
+    logger.warn('Failed to release chat stream lock', {
+      chatId,
+      streamId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  } finally {
+    resolvePendingChatStream(chatId, streamId)
+  }
+}
+
+export async function acquirePendingChatStream(
+  chatId: string,
+  streamId: string,
+  timeoutMs = 5_000
+): Promise<boolean> {
+  const redis = getRedisClient()
+  if (redis) {
+    const deadline = Date.now() + timeoutMs
+    for (;;) {
+      try {
+        const acquired = await acquireLock(
+          getChatStreamLockKey(chatId),
+          streamId,
+          CHAT_STREAM_LOCK_TTL_SECONDS
+        )
+        if (acquired) {
+          registerPendingChatStream(chatId, streamId)
+          return true
+        }
+        if (!pendingChatStreams.has(chatId)) {
+          const ownerStreamId = await redis.get(getChatStreamLockKey(chatId))
+          if (ownerStreamId) {
+            const settled = await waitForPendingChatStream(chatId, 0, ownerStreamId)
+            if (settled) {
+              continue
+            }
+          }
+        }
+      } catch (error) {
+        logger.warn('Failed to acquire chat stream lock', {
+          chatId,
+          streamId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+
+      if (Date.now() >= deadline) {
+        return false
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200))
+    }
+  }
+
+  for (;;) {
+    const existing = pendingChatStreams.get(chatId)
+    if (!existing) {
+      registerPendingChatStream(chatId, streamId)
+      return true
+    }
+
+    const settled = await Promise.race([
+      existing.promise.then(() => true),
+      new Promise<boolean>((resolve) => setTimeout(() => resolve(false), timeoutMs)),
+    ])
+    if (!settled) {
+      return false
+    }
+  }
+}
+
+/**
+ * Returns `true` if it aborted an in-process controller,
+ * `false` if it only wrote the marker (no local controller found).
+ */
+export async function abortActiveStream(streamId: string): Promise<boolean> {
+  await writeAbortMarker(streamId)
+  const controller = activeStreams.get(streamId)
+  if (!controller) return false
+  controller.abort('user_stop:abortActiveStream')
+  activeStreams.delete(streamId)
+  return true
+}
+
+const pollingStreams = new Set<string>()
+
+export function startAbortPoller(
+  streamId: string,
+  abortController: AbortController,
+  options?: { pollMs?: number; requestId?: string }
+): ReturnType<typeof setInterval> {
+  const pollMs = options?.pollMs ?? DEFAULT_ABORT_POLL_MS
+  const requestId = options?.requestId
+
+  return setInterval(() => {
+    if (pollingStreams.has(streamId)) return
+    pollingStreams.add(streamId)
+
+    void (async () => {
+      try {
+        const shouldAbort = await hasAbortMarker(streamId)
+        if (shouldAbort && !abortController.signal.aborted) {
+          abortController.abort('redis_abort_marker:poller')
+          await clearAbortMarker(streamId)
+        }
+      } catch (error) {
+        logger.warn('Failed to poll stream abort marker', {
+          streamId,
+          ...(requestId ? { requestId } : {}),
+          error: error instanceof Error ? error.message : String(error),
+        })
+      } finally {
+        pollingStreams.delete(streamId)
+      }
+    })()
+  }, pollMs)
+}
+
+export async function cleanupAbortMarker(streamId: string): Promise<void> {
+  try {
+    await clearAbortMarker(streamId)
+  } catch (error) {
+    logger.warn('Failed to clear stream abort marker during cleanup', {
+      streamId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/session/buffer.test.ts b/apps/sim/lib/copilot/request/session/buffer.test.ts
new file mode 100644
index 00000000000..4edd7412864
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/buffer.test.ts
@@ -0,0 +1,249 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { createEvent } from '@/lib/copilot/request/session/event'
+
+vi.mock('@sim/logger', () => loggerMock)
+
+type StoredEnvelope = {
+  score: number
+  value: string
+}
+
+const createRedisStub = () => {
+  const counters = new Map<string, number>()
+  const values = new Map<string, string>()
+  const sortedSets = new Map<string, StoredEnvelope[]>()
+
+  const api = {
+    incr: vi.fn().mockImplementation((key: string) => {
+      const next = (counters.get(key) ?? 0) + 1
+      counters.set(key, next)
+      return next
+    }),
+    expire: vi.fn().mockResolvedValue(1),
+    del: vi.fn().mockImplementation((...keys: string[]) => {
+      for (const key of keys) {
+        values.delete(key)
+        sortedSets.delete(key)
+        counters.delete(key)
+      }
+      return Promise.resolve(keys.length)
+    }),
+    zadd: vi.fn().mockImplementation((key: string, score: number, value: string) => {
+      const entries = sortedSets.get(key) ?? []
+      entries.push({ score, value })
+      sortedSets.set(key, entries)
+      return Promise.resolve(1)
+    }),
+    zremrangebyrank: vi.fn().mockImplementation((key: string, start: number, stop: number) => {
+      const entries = [...(sortedSets.get(key) ?? [])].sort((a, b) => a.score - b.score)
+      const normalizedStart = start < 0 ? Math.max(entries.length + start, 0) : start
+      const normalizedStop = stop < 0 ? entries.length + stop : stop
+      const next = entries.filter(
+        (_entry, index) => index < normalizedStart || index > normalizedStop
+      )
+      sortedSets.set(key, next)
+      return Promise.resolve(1)
+    }),
+    zrangebyscore: vi.fn().mockImplementation((key: string, min: number, max: string) => {
+      const upperBound = max === '+inf' ? Number.POSITIVE_INFINITY : Number(max)
+      const entries = [...(sortedSets.get(key) ?? [])]
+        .filter((entry) => entry.score >= min && entry.score <= upperBound)
+        .sort((a, b) => a.score - b.score)
+        .map((entry) => entry.value)
+      return Promise.resolve(entries)
+    }),
+    set: vi.fn().mockImplementation((key: string, value: string) => {
+      values.set(key, value)
+      return Promise.resolve('OK')
+    }),
+    get: vi.fn().mockImplementation((key: string) => Promise.resolve(values.get(key) ?? null)),
+    pipeline: vi.fn().mockImplementation(() => {
+      const operations: Array<() => Promise<unknown>> = []
+      const pipeline = {
+        zadd: (...args: [string, number, string]) => {
+          operations.push(() => api.zadd(...args))
+          return pipeline
+        },
+        expire: (...args: [string, number]) => {
+          operations.push(() => api.expire(...args))
+          return pipeline
+        },
+        set: (...args: [string, string, 'EX', number]) => {
+          operations.push(() => api.set(args[0], args[1]))
+          return pipeline
+        },
+        zremrangebyrank: (...args: [string, number, number]) => {
+          operations.push(() => api.zremrangebyrank(...args))
+          return pipeline
+        },
+        exec: vi.fn().mockImplementation(async () => {
+          const results: Array<[null, unknown]> = []
+          for (const operation of operations) {
+            results.push([null, await operation()])
+          }
+          return results
+        }),
+      }
+      return pipeline
+    }),
+  }
+
+  return api
+}
+
+let mockRedis: ReturnType<typeof createRedisStub>
+
+vi.mock('@/lib/core/config/redis', () => ({
+  getRedisClient: () => mockRedis,
+}))
+
+import {
+  allocateCursor,
+  appendEvent,
+  clearBuffer,
+  readEvents,
+  scheduleBufferCleanup,
+} from '@/lib/copilot/request/session/buffer'
+
+describe('mothership-stream-outbox', () => {
+  beforeEach(() => {
+    mockRedis = createRedisStub()
+    vi.clearAllMocks()
+  })
+
+  it('replays envelopes after a given cursor', async () => {
+    const firstCursor = await allocateCursor('stream-1')
+    const secondCursor = await allocateCursor('stream-1')
+
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: firstCursor.cursor,
+        seq: firstCursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+      })
+    )
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: secondCursor.cursor,
+        seq: secondCursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'world' },
+      })
+    )
+
+    const allEvents = await readEvents('stream-1', '0')
+    expect(allEvents.map((entry) => entry.payload.text)).toEqual(['hello', 'world'])
+
+    const replayed = await readEvents('stream-1', '1')
+    expect(replayed.map((entry) => entry.payload.text)).toEqual(['world'])
+  })
+
+  it('does not trim active stream history while appending events', async () => {
+    const cursor = await allocateCursor('stream-1')
+
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: cursor.cursor,
+        seq: cursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+      })
+    )
+
+    expect(mockRedis.zremrangebyrank).not.toHaveBeenCalled()
+  })
+
+  it('clears persisted stream state during teardown cleanup', async () => {
+    const cursor = await allocateCursor('stream-1')
+
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: cursor.cursor,
+        seq: cursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+      })
+    )
+
+    expect((await readEvents('stream-1', '0')).length).toBe(1)
+
+    await clearBuffer('stream-1')
+
+    expect(await readEvents('stream-1', '0')).toEqual([])
+  })
+
+  it('shortens completed stream retention without deleting replay data immediately', async () => {
+    const cursor = await allocateCursor('stream-1')
+
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: cursor.cursor,
+        seq: cursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+      })
+    )
+
+    await scheduleBufferCleanup('stream-1', 30)
+
+    expect(mockRedis.expire).toHaveBeenCalledWith('mothership_stream:stream-1:events', 30)
+    expect(mockRedis.expire).toHaveBeenCalledWith('mothership_stream:stream-1:seq', 30)
+    expect(mockRedis.expire).toHaveBeenCalledWith('mothership_stream:stream-1:abort', 30)
+    expect((await readEvents('stream-1', '0')).map((entry) => entry.payload.text)).toEqual([
+      'hello',
+    ])
+  })
+
+  it('skips corrupt replay entries that fail stream validation', async () => {
+    const cursor = await allocateCursor('stream-1')
+
+    await appendEvent(
+      createEvent({
+        streamId: 'stream-1',
+        cursor: cursor.cursor,
+        seq: cursor.seq,
+        requestId: 'req-1',
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+      })
+    )
+
+    await mockRedis.zadd(
+      'mothership_stream:stream-1:events',
+      cursor.seq + 1,
+      JSON.stringify({
+        v: 1,
+        type: 'tool',
+        seq: cursor.seq + 1,
+        ts: '2026-04-11T00:00:00.000Z',
+        stream: { streamId: 'stream-1' },
+        payload: { toolCallId: 'broken-tool' },
+      })
+    )
+
+    const replayed = await readEvents('stream-1', '0')
+
+    expect(replayed).toHaveLength(1)
+    expect(replayed[0]?.payload.text).toBe('hello')
+  })
+})
diff --git a/apps/sim/lib/copilot/request/session/buffer.ts b/apps/sim/lib/copilot/request/session/buffer.ts
new file mode 100644
index 00000000000..559d0369e27
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/buffer.ts
@@ -0,0 +1,254 @@
+import { createLogger } from '@sim/logger'
+import { env } from '@/lib/core/config/env'
+import { getRedisClient } from '@/lib/core/config/redis'
+import {
+  type PersistedStreamEventEnvelope,
+  parsePersistedStreamEventEnvelopeJson,
+} from './contract'
+
+const logger = createLogger('SessionBuffer')
+
+const STREAM_OUTBOX_PREFIX = 'mothership_stream:'
+const DEFAULT_TTL_SECONDS = 60 * 60
+const DEFAULT_COMPLETED_TTL_SECONDS = 5 * 60
+const DEFAULT_EVENT_LIMIT = 5_000
+const RETRY_DELAYS_MS = [0, 50, 150] as const
+
+type RedisOperationMetadata = {
+  operation: string
+  streamId: string
+}
+
+function getEventsKey(streamId: string) {
+  return `${STREAM_OUTBOX_PREFIX}${streamId}:events`
+}
+
+function getSeqKey(streamId: string) {
+  return `${STREAM_OUTBOX_PREFIX}${streamId}:seq`
+}
+
+function getAbortKey(streamId: string) {
+  return `${STREAM_OUTBOX_PREFIX}${streamId}:abort`
+}
+
+export type StreamConfig = {
+  ttlSeconds: number
+  eventLimit: number
+}
+
+export function getStreamConfig(): StreamConfig {
+  return {
+    ttlSeconds: parsePositiveNumber(env.COPILOT_STREAM_TTL_SECONDS, DEFAULT_TTL_SECONDS),
+    eventLimit: parsePositiveNumber(env.COPILOT_STREAM_EVENT_LIMIT, DEFAULT_EVENT_LIMIT),
+  }
+}
+
+function parsePositiveNumber(value: number | string | undefined, fallback: number) {
+  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+    return value
+  }
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
+}
+
+async function withRedisRetry<T>(
+  metadata: RedisOperationMetadata,
+  operation: (redis: NonNullable<ReturnType<typeof getRedisClient>>) => Promise<T>
+): Promise<T> {
+  const redis = getRedisClient()
+  if (!redis) {
+    throw new Error('Redis is required for mothership stream durability')
+  }
+
+  let lastError: unknown
+
+  for (let attempt = 0; attempt < RETRY_DELAYS_MS.length; attempt++) {
+    const delay = RETRY_DELAYS_MS[attempt]
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay))
+    }
+
+    try {
+      return await operation(redis)
+    } catch (error) {
+      lastError = error
+      logger.warn('Redis stream operation failed', {
+        operation: metadata.operation,
+        streamId: metadata.streamId,
+        attempt: attempt + 1,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  throw lastError instanceof Error
+    ? lastError
+    : new Error(`${metadata.operation} failed for stream ${metadata.streamId}`)
+}
+
+export async function allocateCursor(streamId: string): Promise<{
+  seq: number
+  cursor: string
+}> {
+  const config = getStreamConfig()
+  const seq = await withRedisRetry({ operation: 'allocate_cursor', streamId }, async (redis) => {
+    const nextValue = await redis.incr(getSeqKey(streamId))
+    await redis.expire(getSeqKey(streamId), config.ttlSeconds)
+    return typeof nextValue === 'number' ? nextValue : Number(nextValue)
+  })
+
+  return { seq, cursor: String(seq) }
+}
+
+export async function resetBuffer(streamId: string): Promise<void> {
+  await clearBuffer(streamId, 'reset_outbox')
+}
+
+export async function clearBuffer(streamId: string, operation = 'clear_outbox'): Promise<void> {
+  await withRedisRetry({ operation, streamId }, async (redis) => {
+    await redis.del(getEventsKey(streamId), getSeqKey(streamId), getAbortKey(streamId))
+  })
+}
+
+export async function scheduleBufferCleanup(
+  streamId: string,
+  ttlSeconds = DEFAULT_COMPLETED_TTL_SECONDS
+): Promise<void> {
+  try {
+    await withRedisRetry({ operation: 'schedule_outbox_cleanup', streamId }, async (redis) => {
+      const pipeline = redis.pipeline()
+      pipeline.expire(getEventsKey(streamId), ttlSeconds)
+      pipeline.expire(getSeqKey(streamId), ttlSeconds)
+      pipeline.expire(getAbortKey(streamId), ttlSeconds)
+      await pipeline.exec()
+    })
+  } catch (error) {
+    logger.warn('Failed to shorten stream buffer TTL during cleanup', {
+      streamId,
+      ttlSeconds,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+export async function appendEvents(
+  envelopes: PersistedStreamEventEnvelope[]
+): Promise<PersistedStreamEventEnvelope[]> {
+  if (envelopes.length === 0) {
+    return envelopes
+  }
+
+  const streamId = envelopes[0].stream.streamId
+  const config = getStreamConfig()
+
+  await withRedisRetry({ operation: 'append_event', streamId }, async (redis) => {
+    const key = getEventsKey(streamId)
+    const seqKey = getSeqKey(streamId)
+    const pipeline = redis.pipeline()
+    const zaddArgs: Array<number | string> = []
+    for (const envelope of envelopes) {
+      zaddArgs.push(envelope.seq, JSON.stringify(envelope))
+    }
+    pipeline.zadd(key, ...(zaddArgs as [number, string, ...Array<number | string>]))
+    pipeline.expire(key, config.ttlSeconds)
+    pipeline.set(seqKey, String(envelopes[envelopes.length - 1].seq), 'EX', config.ttlSeconds)
+    await pipeline.exec()
+  })
+
+  return envelopes
+}
+
+export async function appendEvent(
+  envelope: PersistedStreamEventEnvelope
+): Promise<PersistedStreamEventEnvelope> {
+  await appendEvents([envelope])
+  return envelope
+}
+
+export class InvalidCursorError extends Error {
+  constructor(
+    public readonly streamId: string,
+    public readonly cursor: string
+  ) {
+    super(`Invalid non-numeric cursor "${cursor}" for stream ${streamId}`)
+    this.name = 'InvalidCursorError'
+  }
+}
+
+export async function readEvents(
+  streamId: string,
+  afterCursor: string
+): Promise<PersistedStreamEventEnvelope[]> {
+  const afterSeq = Number(afterCursor || '0')
+  if (!Number.isFinite(afterSeq)) {
+    throw new InvalidCursorError(streamId, afterCursor)
+  }
+  const minScore = afterSeq + 1
+
+  const rawEntries = await withRedisRetry({ operation: 'read_events', streamId }, async (redis) => {
+    return redis.zrangebyscore(getEventsKey(streamId), minScore, '+inf')
+  })
+
+  const envelopes: PersistedStreamEventEnvelope[] = []
+  for (const entry of rawEntries) {
+    const parsed = parsePersistedStreamEventEnvelopeJson(entry)
+    if (!parsed.ok) {
+      logger.warn('Skipping corrupt outbox entry', {
+        streamId,
+        reason: parsed.reason,
+        message: parsed.message,
+        errors: parsed.errors,
+      })
+      continue
+    }
+    envelopes.push(parsed.event)
+  }
+  return envelopes
+}
+
+export async function getOldestSeq(streamId: string): Promise<number | null> {
+  return withRedisRetry({ operation: 'get_oldest_seq', streamId }, async (redis) => {
+    const entries = await redis.zrangebyscore(getEventsKey(streamId), '-inf', '+inf', 'LIMIT', 0, 1)
+    if (!entries || entries.length === 0) {
+      return null
+    }
+    try {
+      const parsed = JSON.parse(entries[0]) as { seq?: number }
+      return typeof parsed.seq === 'number' ? parsed.seq : null
+    } catch {
+      logger.warn('Failed to parse oldest outbox entry', { streamId })
+      return null
+    }
+  })
+}
+
+export async function getLatestSeq(streamId: string): Promise<number | null> {
+  return withRedisRetry({ operation: 'get_latest_seq', streamId }, async (redis) => {
+    const currentSeq = await redis.get(getSeqKey(streamId))
+    if (currentSeq === null) {
+      return null
+    }
+    const parsed = Number(currentSeq)
+    return Number.isFinite(parsed) ? parsed : null
+  })
+}
+
+export async function writeAbortMarker(streamId: string): Promise<void> {
+  const ttlSeconds = getStreamConfig().ttlSeconds
+  await withRedisRetry({ operation: 'write_abort_marker', streamId }, async (redis) => {
+    await redis.set(getAbortKey(streamId), '1', 'EX', ttlSeconds)
+  })
+}
+
+export async function hasAbortMarker(streamId: string): Promise<boolean> {
+  return withRedisRetry({ operation: 'read_abort_marker', streamId }, async (redis) => {
+    const marker = await redis.get(getAbortKey(streamId))
+    return marker === '1'
+  })
+}
+
+export async function clearAbortMarker(streamId: string): Promise<void> {
+  await withRedisRetry({ operation: 'clear_abort_marker', streamId }, async (redis) => {
+    await redis.del(getAbortKey(streamId))
+  })
+}
diff --git a/apps/sim/lib/copilot/request/session/contract.test.ts b/apps/sim/lib/copilot/request/session/contract.test.ts
new file mode 100644
index 00000000000..7b76aec22b7
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/contract.test.ts
@@ -0,0 +1,97 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  isContractStreamEventEnvelope,
+  isSyntheticFilePreviewEventEnvelope,
+  parsePersistedStreamEventEnvelope,
+  parsePersistedStreamEventEnvelopeJson,
+} from './contract'
+
+const BASE_ENVELOPE = {
+  v: 1 as const,
+  seq: 1,
+  ts: '2026-04-11T00:00:00.000Z',
+  stream: {
+    streamId: 'stream-1',
+    cursor: '1',
+  },
+  trace: {
+    requestId: 'req-1',
+  },
+}
+
+describe('stream session contract parser', () => {
+  it('accepts contract text events', () => {
+    const event = {
+      ...BASE_ENVELOPE,
+      type: 'text' as const,
+      payload: {
+        channel: 'assistant' as const,
+        text: 'hello',
+      },
+    }
+
+    expect(isContractStreamEventEnvelope(event)).toBe(true)
+
+    const parsed = parsePersistedStreamEventEnvelope(event)
+    expect(parsed).toEqual({
+      ok: true,
+      event,
+    })
+  })
+
+  it('accepts synthetic file preview events', () => {
+    const event = {
+      ...BASE_ENVELOPE,
+      type: 'tool' as const,
+      payload: {
+        toolCallId: 'preview-1',
+        toolName: 'workspace_file' as const,
+        previewPhase: 'file_preview_content' as const,
+        content: 'draft body',
+        contentMode: 'snapshot' as const,
+        previewVersion: 2,
+        fileName: 'draft.md',
+      },
+    }
+
+    expect(isSyntheticFilePreviewEventEnvelope(event)).toBe(true)
+
+    const parsed = parsePersistedStreamEventEnvelope(event)
+    expect(parsed).toEqual({
+      ok: true,
+      event,
+    })
+  })
+
+  it('rejects invalid tool events with structured validation errors', () => {
+    const parsed = parsePersistedStreamEventEnvelope({
+      ...BASE_ENVELOPE,
+      type: 'tool',
+      payload: {
+        toolCallId: 'tool-1',
+        toolName: 'read',
+      },
+    })
+
+    expect(parsed.ok).toBe(false)
+    if (parsed.ok) {
+      throw new Error('expected invalid result')
+    }
+    expect(parsed.reason).toBe('invalid_stream_event')
+    expect(parsed.errors?.length).toBeGreaterThan(0)
+  })
+
+  it('reports invalid JSON separately from schema failures', () => {
+    const parsed = parsePersistedStreamEventEnvelopeJson('{')
+
+    expect(parsed.ok).toBe(false)
+    if (parsed.ok) {
+      throw new Error('expected invalid json result')
+    }
+    expect(parsed.reason).toBe('invalid_json')
+  })
+})
diff --git a/apps/sim/lib/copilot/request/session/contract.ts b/apps/sim/lib/copilot/request/session/contract.ts
new file mode 100644
index 00000000000..3a592dc7076
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/contract.ts
@@ -0,0 +1,335 @@
+import type { ErrorObject, ValidateFunction } from 'ajv'
+import Ajv2020 from 'ajv/dist/2020.js'
+import type {
+  MothershipStreamV1EventEnvelope,
+  MothershipStreamV1StreamRef,
+  MothershipStreamV1StreamScope,
+  MothershipStreamV1Trace,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { MOTHERSHIP_STREAM_V1_SCHEMA } from '@/lib/copilot/generated/mothership-stream-v1-schema'
+import type { FilePreviewTargetKind } from './file-preview-session-contract'
+
+type JsonRecord = Record<string, unknown>
+
+const ajv = new Ajv2020({
+  allErrors: true,
+  strict: false,
+})
+
+const FILE_PREVIEW_PHASE = {
+  start: 'file_preview_start',
+  target: 'file_preview_target',
+  editMeta: 'file_preview_edit_meta',
+  content: 'file_preview_content',
+  complete: 'file_preview_complete',
+} as const
+
+type EnvelopeToStreamEvent<T> = T extends {
+  type: infer TType
+  payload: infer TPayload
+  scope?: infer TScope
+}
+  ? { type: TType; payload: TPayload; scope?: Exclude<TScope, undefined> }
+  : never
+
+export type SyntheticFilePreviewPhase = (typeof FILE_PREVIEW_PHASE)[keyof typeof FILE_PREVIEW_PHASE]
+
+export interface SyntheticFilePreviewTarget {
+  kind: FilePreviewTargetKind
+  fileId?: string
+  fileName?: string
+}
+
+export interface SyntheticFilePreviewStartPayload {
+  previewPhase: typeof FILE_PREVIEW_PHASE.start
+  toolCallId: string
+  toolName: 'workspace_file'
+}
+
+export interface SyntheticFilePreviewTargetPayload {
+  operation?: string
+  previewPhase: typeof FILE_PREVIEW_PHASE.target
+  target: SyntheticFilePreviewTarget
+  title?: string
+  toolCallId: string
+  toolName: 'workspace_file'
+}
+
+export interface SyntheticFilePreviewEditMetaPayload {
+  edit: JsonRecord
+  previewPhase: typeof FILE_PREVIEW_PHASE.editMeta
+  toolCallId: string
+  toolName: 'workspace_file'
+}
+
+export interface SyntheticFilePreviewContentPayload {
+  content: string
+  contentMode: 'delta' | 'snapshot'
+  edit?: JsonRecord
+  fileId?: string
+  fileName: string
+  operation?: string
+  previewPhase: typeof FILE_PREVIEW_PHASE.content
+  previewVersion: number
+  targetKind?: string
+  toolCallId: string
+  toolName: 'workspace_file'
+}
+
+export interface SyntheticFilePreviewCompletePayload {
+  fileId?: string
+  output?: unknown
+  previewPhase: typeof FILE_PREVIEW_PHASE.complete
+  previewVersion?: number
+  toolCallId: string
+  toolName: 'workspace_file'
+}
+
+export type SyntheticFilePreviewPayload =
+  | SyntheticFilePreviewStartPayload
+  | SyntheticFilePreviewTargetPayload
+  | SyntheticFilePreviewEditMetaPayload
+  | SyntheticFilePreviewContentPayload
+  | SyntheticFilePreviewCompletePayload
+
+export interface SyntheticFilePreviewEventEnvelope {
+  payload: SyntheticFilePreviewPayload
+  scope?: MothershipStreamV1StreamScope
+  seq: number
+  stream: MothershipStreamV1StreamRef
+  trace?: MothershipStreamV1Trace
+  ts: string
+  type: 'tool'
+  v: 1
+}
+
+export type PersistedStreamEventEnvelope =
+  | MothershipStreamV1EventEnvelope
+  | SyntheticFilePreviewEventEnvelope
+
+export type ContractStreamEvent = EnvelopeToStreamEvent<MothershipStreamV1EventEnvelope>
+export type SyntheticStreamEvent = EnvelopeToStreamEvent<SyntheticFilePreviewEventEnvelope>
+export type SessionStreamEvent = ContractStreamEvent | SyntheticStreamEvent
+export type StreamEvent = SessionStreamEvent
+export type ToolCallStreamEvent = Extract<
+  ContractStreamEvent,
+  { type: 'tool'; payload: { phase: 'call' } }
+>
+export type ToolArgsDeltaStreamEvent = Extract<
+  ContractStreamEvent,
+  { type: 'tool'; payload: { phase: 'args_delta' } }
+>
+export type ToolResultStreamEvent = Extract<
+  ContractStreamEvent,
+  { type: 'tool'; payload: { phase: 'result' } }
+>
+export type SubagentSpanStreamEvent = Extract<
+  ContractStreamEvent,
+  { type: 'span'; payload: { kind: 'subagent' } }
+>
+
+export interface ParseStreamEventEnvelopeSuccess {
+  ok: true
+  event: PersistedStreamEventEnvelope
+}
+
+export interface ParseStreamEventEnvelopeFailure {
+  errors?: string[]
+  message: string
+  ok: false
+  reason: 'invalid_json' | 'invalid_stream_event'
+}
+
+export type ParseStreamEventEnvelopeResult =
+  | ParseStreamEventEnvelopeSuccess
+  | ParseStreamEventEnvelopeFailure
+
+let validator: ValidateFunction<MothershipStreamV1EventEnvelope> | null = null
+
+function getValidator(): ValidateFunction<MothershipStreamV1EventEnvelope> {
+  if (validator) {
+    return validator
+  }
+
+  validator = ajv.compile<MothershipStreamV1EventEnvelope>(MOTHERSHIP_STREAM_V1_SCHEMA as object)
+  return validator
+}
+
+function formatValidationErrors(errors: ErrorObject[] | null | undefined): string[] | undefined {
+  if (!errors || errors.length === 0) {
+    return undefined
+  }
+
+  return errors
+    .slice(0, 5)
+    .map((error) => `${error.instancePath || '/'} ${error.message || 'is invalid'}`.trim())
+}
+
+function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function isOptionalString(value: unknown): value is string | undefined {
+  return value === undefined || typeof value === 'string'
+}
+
+function isOptionalFiniteNumber(value: unknown): value is number | undefined {
+  return value === undefined || (typeof value === 'number' && Number.isFinite(value))
+}
+
+function isStreamRef(value: unknown): value is MothershipStreamV1StreamRef {
+  return (
+    isRecord(value) &&
+    typeof value.streamId === 'string' &&
+    isOptionalString(value.chatId) &&
+    isOptionalString(value.cursor)
+  )
+}
+
+function isTrace(value: unknown): value is MothershipStreamV1Trace {
+  return isRecord(value) && typeof value.requestId === 'string' && isOptionalString(value.spanId)
+}
+
+function isStreamScope(value: unknown): value is MothershipStreamV1StreamScope {
+  return (
+    isRecord(value) &&
+    value.lane === 'subagent' &&
+    isOptionalString(value.agentId) &&
+    isOptionalString(value.parentToolCallId)
+  )
+}
+
+function isSyntheticEnvelopeBase(
+  value: unknown
+): value is Omit<SyntheticFilePreviewEventEnvelope, 'payload'> & { payload?: unknown } {
+  return (
+    isRecord(value) &&
+    value.v === 1 &&
+    value.type === 'tool' &&
+    typeof value.seq === 'number' &&
+    Number.isFinite(value.seq) &&
+    typeof value.ts === 'string' &&
+    isStreamRef(value.stream) &&
+    (value.trace === undefined || isTrace(value.trace)) &&
+    (value.scope === undefined || isStreamScope(value.scope))
+  )
+}
+
+function isSyntheticFilePreviewTarget(value: unknown): value is SyntheticFilePreviewTarget {
+  return (
+    isRecord(value) &&
+    (value.kind === 'new_file' || value.kind === 'file_id') &&
+    isOptionalString(value.fileId) &&
+    isOptionalString(value.fileName)
+  )
+}
+
+function isSyntheticFilePreviewPayload(value: unknown): value is SyntheticFilePreviewPayload {
+  if (!isRecord(value)) {
+    return false
+  }
+
+  if (typeof value.toolCallId !== 'string' || value.toolName !== 'workspace_file') {
+    return false
+  }
+
+  switch (value.previewPhase) {
+    case FILE_PREVIEW_PHASE.start:
+      return true
+    case FILE_PREVIEW_PHASE.target:
+      return (
+        isSyntheticFilePreviewTarget(value.target) &&
+        isOptionalString(value.operation) &&
+        isOptionalString(value.title)
+      )
+    case FILE_PREVIEW_PHASE.editMeta:
+      return isRecord(value.edit)
+    case FILE_PREVIEW_PHASE.content:
+      return (
+        typeof value.content === 'string' &&
+        (value.contentMode === 'delta' || value.contentMode === 'snapshot') &&
+        typeof value.previewVersion === 'number' &&
+        Number.isFinite(value.previewVersion) &&
+        typeof value.fileName === 'string' &&
+        isOptionalString(value.fileId) &&
+        isOptionalString(value.targetKind) &&
+        isOptionalString(value.operation) &&
+        (value.edit === undefined || isRecord(value.edit))
+      )
+    case FILE_PREVIEW_PHASE.complete:
+      return isOptionalString(value.fileId) && isOptionalFiniteNumber(value.previewVersion)
+    default:
+      return false
+  }
+}
+
+export function isSyntheticFilePreviewEventEnvelope(
+  value: unknown
+): value is SyntheticFilePreviewEventEnvelope {
+  return isSyntheticEnvelopeBase(value) && isSyntheticFilePreviewPayload(value.payload)
+}
+
+export function isToolCallStreamEvent(event: SessionStreamEvent): event is ToolCallStreamEvent {
+  return event.type === 'tool' && isRecord(event.payload) && event.payload.phase === 'call'
+}
+
+export function isToolArgsDeltaStreamEvent(
+  event: SessionStreamEvent
+): event is ToolArgsDeltaStreamEvent {
+  return event.type === 'tool' && isRecord(event.payload) && event.payload.phase === 'args_delta'
+}
+
+export function isToolResultStreamEvent(event: SessionStreamEvent): event is ToolResultStreamEvent {
+  return event.type === 'tool' && isRecord(event.payload) && event.payload.phase === 'result'
+}
+
+export function isSubagentSpanStreamEvent(
+  event: SessionStreamEvent
+): event is SubagentSpanStreamEvent {
+  return event.type === 'span' && isRecord(event.payload) && event.payload.kind === 'subagent'
+}
+
+export function isContractStreamEventEnvelope(
+  value: unknown
+): value is MothershipStreamV1EventEnvelope {
+  return getValidator()(value)
+}
+
+export function parsePersistedStreamEventEnvelope(value: unknown): ParseStreamEventEnvelopeResult {
+  const envelopeValidator = getValidator()
+  if (envelopeValidator(value)) {
+    return {
+      ok: true,
+      event: value,
+    }
+  }
+
+  if (isSyntheticFilePreviewEventEnvelope(value)) {
+    return {
+      ok: true,
+      event: value,
+    }
+  }
+
+  return {
+    ok: false,
+    reason: 'invalid_stream_event',
+    message: 'Stream event failed validation',
+    errors: formatValidationErrors(envelopeValidator.errors),
+  }
+}
+
+export function parsePersistedStreamEventEnvelopeJson(raw: string): ParseStreamEventEnvelopeResult {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch (error) {
+    return {
+      ok: false,
+      reason: 'invalid_json',
+      message: error instanceof Error ? error.message : 'Invalid JSON',
+    }
+  }
+
+  return parsePersistedStreamEventEnvelope(parsed)
+}
diff --git a/apps/sim/lib/copilot/request/session/event.test.ts b/apps/sim/lib/copilot/request/session/event.test.ts
new file mode 100644
index 00000000000..0f0573a24f8
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/event.test.ts
@@ -0,0 +1,63 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { parsePersistedStreamEventEnvelope } from '@/lib/copilot/request/session'
+import { createEvent, eventToStreamEvent } from '@/lib/copilot/request/session/event'
+
+describe('createEvent', () => {
+  it('creates contract envelopes that pass validation', () => {
+    const envelope = createEvent({
+      streamId: 'stream-1',
+      cursor: '1',
+      seq: 1,
+      requestId: 'req-1',
+      type: MothershipStreamV1EventType.text,
+      payload: {
+        channel: MothershipStreamV1TextChannel.assistant,
+        text: 'hello',
+      },
+    })
+
+    const parsed = parsePersistedStreamEventEnvelope(envelope)
+    expect(parsed.ok).toBe(true)
+    expect(envelope.type).toBe(MothershipStreamV1EventType.text)
+    expect(envelope.payload).toEqual({
+      channel: MothershipStreamV1TextChannel.assistant,
+      text: 'hello',
+    })
+  })
+
+  it('creates synthetic preview envelopes that round-trip to stream events', () => {
+    const envelope = createEvent({
+      streamId: 'stream-1',
+      cursor: '2',
+      seq: 2,
+      requestId: 'req-1',
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        previewPhase: 'file_preview_start',
+        toolCallId: 'preview-1',
+        toolName: 'workspace_file',
+      },
+    })
+
+    const parsed = parsePersistedStreamEventEnvelope(envelope)
+    expect(parsed.ok).toBe(true)
+
+    const streamEvent = eventToStreamEvent(envelope)
+    expect(streamEvent).toEqual({
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        previewPhase: 'file_preview_start',
+        toolCallId: 'preview-1',
+        toolName: 'workspace_file',
+      },
+    })
+  })
+})
diff --git a/apps/sim/lib/copilot/request/session/event.ts b/apps/sim/lib/copilot/request/session/event.ts
new file mode 100644
index 00000000000..67be1dd721e
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/event.ts
@@ -0,0 +1,74 @@
+import {
+  type PersistedStreamEventEnvelope,
+  parsePersistedStreamEventEnvelope,
+  type SessionStreamEvent,
+} from './contract'
+
+type CreateEventBase = {
+  chatId?: string
+  cursor: string
+  requestId: string
+  seq: number
+  streamId: string
+  ts?: string
+}
+
+type CreateEventVariant<TEvent extends SessionStreamEvent> = CreateEventBase &
+  Pick<TEvent, 'type' | 'payload' | 'scope'>
+
+export type CreateEventInput = SessionStreamEvent extends infer TEvent
+  ? TEvent extends SessionStreamEvent
+    ? CreateEventVariant<TEvent>
+    : never
+  : never
+
+type CreateEventResult<TInput extends CreateEventInput> = Extract<
+  PersistedStreamEventEnvelope,
+  { type: TInput['type']; payload: TInput['payload'] }
+>
+
+type StreamEventFromEnvelope<TEnvelope extends PersistedStreamEventEnvelope> = Extract<
+  SessionStreamEvent,
+  { type: TEnvelope['type']; payload: TEnvelope['payload'] }
+>
+
+export const TOOL_CALL_STATUS = {
+  generating: 'generating',
+} as const
+
+export function createEvent<TInput extends CreateEventInput>(
+  input: TInput
+): CreateEventResult<TInput> {
+  const { streamId, chatId, cursor, seq, requestId, type, payload, scope, ts } = input
+
+  return {
+    v: 1,
+    type,
+    seq,
+    ts: ts ?? new Date().toISOString(),
+    stream: {
+      streamId,
+      ...(chatId ? { chatId } : {}),
+      cursor,
+    },
+    trace: {
+      requestId,
+    },
+    ...(scope ? { scope } : {}),
+    payload,
+  } as CreateEventResult<TInput>
+}
+
+export function isEventRecord(value: unknown): value is PersistedStreamEventEnvelope {
+  return parsePersistedStreamEventEnvelope(value).ok
+}
+
+export function eventToStreamEvent<TEnvelope extends PersistedStreamEventEnvelope>(
+  envelope: TEnvelope
+): StreamEventFromEnvelope<TEnvelope> {
+  return {
+    type: envelope.type,
+    payload: envelope.payload,
+    ...(envelope.scope ? { scope: envelope.scope } : {}),
+  } as StreamEventFromEnvelope<TEnvelope>
+}
diff --git a/apps/sim/lib/copilot/request/session/explicit-abort.ts b/apps/sim/lib/copilot/request/session/explicit-abort.ts
new file mode 100644
index 00000000000..7aad5465544
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/explicit-abort.ts
@@ -0,0 +1,40 @@
+import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import { env } from '@/lib/core/config/env'
+
+export const DEFAULT_EXPLICIT_ABORT_TIMEOUT_MS = 3000
+
+export async function requestExplicitStreamAbort(params: {
+  streamId: string
+  userId: string
+  chatId?: string
+  timeoutMs?: number
+}): Promise<void> {
+  const { streamId, userId, chatId, timeoutMs = DEFAULT_EXPLICIT_ABORT_TIMEOUT_MS } = params
+
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+  if (env.COPILOT_API_KEY) {
+    headers['x-api-key'] = env.COPILOT_API_KEY
+  }
+
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort('timeout:go_explicit_abort_fetch'), timeoutMs)
+
+  try {
+    const response = await fetch(`${SIM_AGENT_API_URL}/api/streams/explicit-abort`, {
+      method: 'POST',
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify({
+        messageId: streamId,
+        userId,
+        ...(chatId ? { chatId } : {}),
+      }),
+    })
+
+    if (!response.ok) {
+      throw new Error(`Explicit abort marker request failed: ${response.status}`)
+    }
+  } finally {
+    clearTimeout(timeout)
+  }
+}
diff --git a/apps/sim/lib/copilot/request/session/file-preview-session-contract.ts b/apps/sim/lib/copilot/request/session/file-preview-session-contract.ts
new file mode 100644
index 00000000000..a2e96208ba1
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/file-preview-session-contract.ts
@@ -0,0 +1,53 @@
+export const FILE_PREVIEW_SESSION_SCHEMA_VERSION = 1 as const
+
+export type FilePreviewTargetKind = 'new_file' | 'file_id'
+export type FilePreviewStatus = 'pending' | 'streaming' | 'complete'
+export type FilePreviewContentMode = 'delta' | 'snapshot'
+
+export interface FilePreviewSession {
+  schemaVersion: typeof FILE_PREVIEW_SESSION_SCHEMA_VERSION
+  id: string
+  streamId: string
+  toolCallId: string
+  status: FilePreviewStatus
+  fileName: string
+  fileId?: string
+  targetKind?: FilePreviewTargetKind
+  operation?: string
+  edit?: Record<string, unknown>
+  baseContent?: string
+  previewText: string
+  previewVersion: number
+  updatedAt: string
+  completedAt?: string
+}
+
+export function isFilePreviewSession(value: unknown): value is FilePreviewSession {
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+
+  const record = value as Record<string, unknown>
+  return (
+    record.schemaVersion === FILE_PREVIEW_SESSION_SCHEMA_VERSION &&
+    typeof record.id === 'string' &&
+    typeof record.streamId === 'string' &&
+    typeof record.toolCallId === 'string' &&
+    typeof record.status === 'string' &&
+    typeof record.fileName === 'string' &&
+    (record.baseContent === undefined || typeof record.baseContent === 'string') &&
+    typeof record.previewText === 'string' &&
+    typeof record.previewVersion === 'number' &&
+    typeof record.updatedAt === 'string'
+  )
+}
+
+export function sortFilePreviewSessions(sessions: FilePreviewSession[]): FilePreviewSession[] {
+  return [...sessions].sort((a, b) => {
+    const updatedAtCompare = a.updatedAt.localeCompare(b.updatedAt)
+    if (updatedAtCompare !== 0) {
+      return updatedAtCompare
+    }
+    return a.id.localeCompare(b.id)
+  })
+}
diff --git a/apps/sim/lib/copilot/request/session/file-preview-session.test.ts b/apps/sim/lib/copilot/request/session/file-preview-session.test.ts
new file mode 100644
index 00000000000..c994dae0b6e
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/file-preview-session.test.ts
@@ -0,0 +1,42 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  createFilePreviewSession,
+  sortFilePreviewSessions,
+} from '@/lib/copilot/request/session/file-preview-session'
+
+describe('file preview session helpers', () => {
+  it('preserves baseContent when creating a preview session', () => {
+    const session = createFilePreviewSession({
+      streamId: 'stream-1',
+      toolCallId: 'preview-1',
+      fileName: 'draft.md',
+      baseContent: 'existing content',
+    })
+
+    expect(session.baseContent).toBe('existing content')
+  })
+
+  it('sorts preview sessions by updatedAt across tool call ids', () => {
+    const sessions = sortFilePreviewSessions([
+      createFilePreviewSession({
+        streamId: 'stream-1',
+        toolCallId: 'preview-2',
+        fileName: 'b.md',
+        previewVersion: 10,
+        updatedAt: '2026-04-10T00:00:02.000Z',
+      }),
+      createFilePreviewSession({
+        streamId: 'stream-1',
+        toolCallId: 'preview-1',
+        fileName: 'a.md',
+        previewVersion: 1,
+        updatedAt: '2026-04-10T00:00:01.000Z',
+      }),
+    ])
+
+    expect(sessions.map((session) => session.id)).toEqual(['preview-1', 'preview-2'])
+  })
+})
diff --git a/apps/sim/lib/copilot/request/session/file-preview-session.ts b/apps/sim/lib/copilot/request/session/file-preview-session.ts
new file mode 100644
index 00000000000..eda86d4612c
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/file-preview-session.ts
@@ -0,0 +1,177 @@
+import { createLogger } from '@sim/logger'
+import { getRedisClient } from '@/lib/core/config/redis'
+import { getStreamConfig } from './buffer'
+import {
+  FILE_PREVIEW_SESSION_SCHEMA_VERSION,
+  type FilePreviewSession,
+  type FilePreviewStatus,
+  type FilePreviewTargetKind,
+  isFilePreviewSession,
+  sortFilePreviewSessions,
+} from './file-preview-session-contract'
+
+const logger = createLogger('FilePreviewSessionStore')
+
+const STREAM_OUTBOX_PREFIX = 'mothership_stream:'
+const DEFAULT_COMPLETED_TTL_SECONDS = 5 * 60
+const RETRY_DELAYS_MS = [0, 50, 150] as const
+
+export type {
+  FilePreviewContentMode,
+  FilePreviewSession,
+  FilePreviewStatus,
+  FilePreviewTargetKind,
+} from './file-preview-session-contract'
+export {
+  FILE_PREVIEW_SESSION_SCHEMA_VERSION,
+  isFilePreviewSession,
+  sortFilePreviewSessions,
+} from './file-preview-session-contract'
+
+function getPreviewSessionsKey(streamId: string): string {
+  return `${STREAM_OUTBOX_PREFIX}${streamId}:preview_sessions`
+}
+
+type RedisOperationMetadata = {
+  operation: string
+  streamId: string
+}
+
+async function withRedisRetry<T>(
+  metadata: RedisOperationMetadata,
+  operation: (redis: NonNullable<ReturnType<typeof getRedisClient>>) => Promise<T>
+): Promise<T> {
+  const redis = getRedisClient()
+  if (!redis) {
+    throw new Error('Redis is required for mothership preview durability')
+  }
+
+  let lastError: unknown
+
+  for (let attempt = 0; attempt < RETRY_DELAYS_MS.length; attempt++) {
+    const delay = RETRY_DELAYS_MS[attempt]
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay))
+    }
+
+    try {
+      return await operation(redis)
+    } catch (error) {
+      lastError = error
+      logger.warn('Redis preview session operation failed', {
+        operation: metadata.operation,
+        streamId: metadata.streamId,
+        attempt: attempt + 1,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  throw lastError instanceof Error
+    ? lastError
+    : new Error(`${metadata.operation} failed for stream ${metadata.streamId}`)
+}
+
+export function createFilePreviewSession(input: {
+  streamId: string
+  toolCallId: string
+  fileName?: string
+  fileId?: string
+  targetKind?: FilePreviewTargetKind
+  operation?: string
+  edit?: Record<string, unknown>
+  baseContent?: string
+  previewText?: string
+  previewVersion?: number
+  status?: FilePreviewStatus
+  updatedAt?: string
+  completedAt?: string
+}): FilePreviewSession {
+  return {
+    schemaVersion: FILE_PREVIEW_SESSION_SCHEMA_VERSION,
+    id: input.toolCallId,
+    streamId: input.streamId,
+    toolCallId: input.toolCallId,
+    status: input.status ?? 'pending',
+    fileName: input.fileName ?? '',
+    ...(input.fileId ? { fileId: input.fileId } : {}),
+    ...(input.targetKind ? { targetKind: input.targetKind } : {}),
+    ...(input.operation ? { operation: input.operation } : {}),
+    ...(input.edit ? { edit: input.edit } : {}),
+    ...(typeof input.baseContent === 'string' ? { baseContent: input.baseContent } : {}),
+    previewText: input.previewText ?? '',
+    previewVersion: input.previewVersion ?? 0,
+    updatedAt: input.updatedAt ?? new Date().toISOString(),
+    ...(input.completedAt ? { completedAt: input.completedAt } : {}),
+  }
+}
+
+export async function upsertFilePreviewSession(
+  session: FilePreviewSession
+): Promise<FilePreviewSession> {
+  const config = getStreamConfig()
+  await withRedisRetry(
+    { operation: 'upsert_preview_session', streamId: session.streamId },
+    async (redis) => {
+      const key = getPreviewSessionsKey(session.streamId)
+      const pipeline = redis.pipeline()
+      pipeline.hset(key, session.id, JSON.stringify(session))
+      pipeline.expire(key, config.ttlSeconds)
+      await pipeline.exec()
+    }
+  )
+  return session
+}
+
+export async function readFilePreviewSessions(streamId: string): Promise<FilePreviewSession[]> {
+  const raw = await withRedisRetry(
+    { operation: 'read_preview_sessions', streamId },
+    async (redis) => redis.hgetall(getPreviewSessionsKey(streamId))
+  )
+
+  const sessions: FilePreviewSession[] = []
+  const values = Object.values(raw ?? {})
+  for (const entry of values) {
+    try {
+      const parsed = JSON.parse(entry) as unknown
+      if (!isFilePreviewSession(parsed)) {
+        logger.warn('Skipping invalid file preview session entry', { streamId })
+        continue
+      }
+      sessions.push(parsed)
+    } catch (error) {
+      logger.warn('Failed to parse file preview session entry', {
+        streamId,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  return sortFilePreviewSessions(sessions)
+}
+
+export async function clearFilePreviewSessions(streamId: string): Promise<void> {
+  await withRedisRetry({ operation: 'clear_preview_sessions', streamId }, async (redis) => {
+    await redis.del(getPreviewSessionsKey(streamId))
+  })
+}
+
+export async function scheduleFilePreviewSessionCleanup(
+  streamId: string,
+  ttlSeconds = DEFAULT_COMPLETED_TTL_SECONDS
+): Promise<void> {
+  try {
+    await withRedisRetry(
+      { operation: 'schedule_preview_session_cleanup', streamId },
+      async (redis) => {
+        await redis.expire(getPreviewSessionsKey(streamId), ttlSeconds)
+      }
+    )
+  } catch (error) {
+    logger.warn('Failed to shorten preview session retention', {
+      streamId,
+      ttlSeconds,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/session/index.ts b/apps/sim/lib/copilot/request/session/index.ts
new file mode 100644
index 00000000000..70466d11b7a
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/index.ts
@@ -0,0 +1,71 @@
+export {
+  abortActiveStream,
+  acquirePendingChatStream,
+  cleanupAbortMarker,
+  getPendingChatStreamId,
+  registerActiveStream,
+  releasePendingChatStream,
+  startAbortPoller,
+  unregisterActiveStream,
+  waitForPendingChatStream,
+} from './abort'
+export {
+  allocateCursor,
+  appendEvent,
+  appendEvents,
+  clearAbortMarker,
+  clearBuffer,
+  getLatestSeq,
+  getOldestSeq,
+  hasAbortMarker,
+  InvalidCursorError,
+  readEvents,
+  resetBuffer,
+  scheduleBufferCleanup,
+  writeAbortMarker,
+} from './buffer'
+export type {
+  ContractStreamEvent,
+  PersistedStreamEventEnvelope,
+  SessionStreamEvent,
+  StreamEvent,
+  SubagentSpanStreamEvent,
+  SyntheticFilePreviewEventEnvelope,
+  SyntheticFilePreviewPayload,
+  SyntheticStreamEvent,
+  ToolArgsDeltaStreamEvent,
+  ToolCallStreamEvent,
+  ToolResultStreamEvent,
+} from './contract'
+export {
+  isContractStreamEventEnvelope,
+  isSubagentSpanStreamEvent,
+  isSyntheticFilePreviewEventEnvelope,
+  isToolArgsDeltaStreamEvent,
+  isToolCallStreamEvent,
+  isToolResultStreamEvent,
+  parsePersistedStreamEventEnvelope,
+  parsePersistedStreamEventEnvelopeJson,
+} from './contract'
+export { createEvent, eventToStreamEvent, isEventRecord, TOOL_CALL_STATUS } from './event'
+export {
+  clearFilePreviewSessions,
+  createFilePreviewSession,
+  readFilePreviewSessions,
+  scheduleFilePreviewSessionCleanup,
+  upsertFilePreviewSession,
+} from './file-preview-session'
+export type {
+  FilePreviewContentMode,
+  FilePreviewSession,
+  FilePreviewStatus,
+  FilePreviewTargetKind,
+} from './file-preview-session-contract'
+export {
+  FILE_PREVIEW_SESSION_SCHEMA_VERSION,
+  isFilePreviewSession,
+} from './file-preview-session-contract'
+export { checkForReplayGap, type ReplayGapResult } from './recovery'
+export { encodeSSEComment, encodeSSEEnvelope, SSE_RESPONSE_HEADERS } from './sse'
+export type { StreamBatchEvent } from './types'
+export { StreamWriter, type StreamWriterOptions } from './writer'
diff --git a/apps/sim/lib/copilot/request/session/recovery.ts b/apps/sim/lib/copilot/request/session/recovery.ts
new file mode 100644
index 00000000000..74612b59211
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/recovery.ts
@@ -0,0 +1,76 @@
+import { createLogger } from '@sim/logger'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { getLatestSeq, getOldestSeq } from './buffer'
+import { createEvent } from './event'
+
+const logger = createLogger('SessionRecovery')
+
+export interface ReplayGapResult {
+  gapDetected: true
+  envelopes: ReturnType<typeof createEvent>[]
+}
+
+export async function checkForReplayGap(
+  streamId: string,
+  afterCursor: string
+): Promise<ReplayGapResult | null> {
+  const requestedAfterSeq = Number(afterCursor || '0')
+  if (requestedAfterSeq <= 0) {
+    return null
+  }
+
+  const oldestSeq = await getOldestSeq(streamId)
+  const latestSeq = await getLatestSeq(streamId)
+
+  if (
+    latestSeq !== null &&
+    latestSeq > 0 &&
+    oldestSeq !== null &&
+    requestedAfterSeq < oldestSeq - 1
+  ) {
+    logger.warn('Replay gap detected: requested cursor is below oldest available event', {
+      streamId,
+      requestedAfterSeq,
+      oldestAvailableSeq: oldestSeq,
+      latestSeq,
+    })
+
+    const gapEnvelope = createEvent({
+      streamId,
+      cursor: String(latestSeq + 1),
+      seq: latestSeq + 1,
+      requestId: '',
+      type: MothershipStreamV1EventType.error,
+      payload: {
+        message: 'Replay history is no longer available. Some events may have been lost.',
+        code: 'replay_gap',
+        data: {
+          oldestAvailableSeq: oldestSeq,
+          requestedAfterSeq,
+        },
+      },
+    })
+
+    const terminalEnvelope = createEvent({
+      streamId,
+      cursor: String(latestSeq + 2),
+      seq: latestSeq + 2,
+      requestId: '',
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: MothershipStreamV1CompletionStatus.error,
+        reason: 'replay_gap',
+      },
+    })
+
+    return {
+      gapDetected: true,
+      envelopes: [gapEnvelope, terminalEnvelope],
+    }
+  }
+
+  return null
+}
diff --git a/apps/sim/lib/copilot/request/session/sse.ts b/apps/sim/lib/copilot/request/session/sse.ts
new file mode 100644
index 00000000000..74b11454047
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/sse.ts
@@ -0,0 +1,16 @@
+import { SSE_HEADERS } from '@/lib/core/utils/sse'
+
+const encoder = new TextEncoder()
+
+export function encodeSSEEnvelope(envelope: unknown): Uint8Array {
+  return encoder.encode(`data: ${JSON.stringify(envelope)}\n\n`)
+}
+
+export function encodeSSEComment(comment: string): Uint8Array {
+  return encoder.encode(`: ${comment}\n\n`)
+}
+
+export const SSE_RESPONSE_HEADERS = {
+  ...SSE_HEADERS,
+  'Content-Encoding': 'none',
+} as const
diff --git a/apps/sim/lib/copilot/request/session/types.ts b/apps/sim/lib/copilot/request/session/types.ts
new file mode 100644
index 00000000000..0cc5e030e23
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/types.ts
@@ -0,0 +1,35 @@
+import type { PersistedStreamEventEnvelope, SessionStreamEvent } from './contract'
+import { parsePersistedStreamEventEnvelope } from './contract'
+
+export type StreamEvent = SessionStreamEvent
+
+export interface StreamBatchEvent {
+  eventId: number
+  streamId: string
+  event: PersistedStreamEventEnvelope
+}
+
+export function toStreamBatchEvent(envelope: PersistedStreamEventEnvelope): StreamBatchEvent {
+  return {
+    eventId: envelope.seq,
+    streamId: envelope.stream.streamId,
+    event: envelope,
+  }
+}
+
+export function isStreamBatchEvent(value: unknown): value is StreamBatchEvent {
+  if (!value || typeof value !== 'object') {
+    return false
+  }
+
+  const record = value as Record<string, unknown>
+  if (
+    typeof record.eventId !== 'number' ||
+    !Number.isFinite(record.eventId) ||
+    typeof record.streamId !== 'string'
+  ) {
+    return false
+  }
+
+  return parsePersistedStreamEventEnvelope(record.event).ok
+}
diff --git a/apps/sim/lib/copilot/request/session/writer.test.ts b/apps/sim/lib/copilot/request/session/writer.test.ts
new file mode 100644
index 00000000000..aa3eb5384ea
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/writer.test.ts
@@ -0,0 +1,189 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent } from '@/lib/copilot/request/session'
+
+const { appendEvents } = vi.hoisted(() => ({
+  appendEvents: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/session/buffer', () => ({
+  appendEvents,
+}))
+
+import { StreamWriter } from '@/lib/copilot/request/session/writer'
+
+function decodeChunk(value: Uint8Array): string {
+  return new TextDecoder().decode(value)
+}
+
+describe('StreamWriter', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.useRealTimers()
+  })
+
+  it('enqueues before persistence completes and flushes pending writes on close', async () => {
+    let releasePersist: (() => void) | null = null
+    appendEvents.mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          releasePersist = resolve
+        })
+    )
+
+    const writer = new StreamWriter({
+      streamId: 'stream-1',
+      chatId: 'chat-1',
+      requestId: 'req-1',
+    })
+
+    const chunks: string[] = []
+    let closeCount = 0
+    const controller = {
+      enqueue: vi.fn((value: Uint8Array) => {
+        chunks.push(decodeChunk(value))
+      }),
+      close: vi.fn(() => {
+        closeCount += 1
+      }),
+    } as unknown as ReadableStreamDefaultController
+
+    writer.attach(controller)
+    await writer.publish({
+      type: MothershipStreamV1EventType.text,
+      payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'hello' },
+    })
+
+    expect(controller.enqueue).toHaveBeenCalledOnce()
+    expect(appendEvents).not.toHaveBeenCalled()
+    expect(chunks[0]).toContain('"text":"hello"')
+    expect(closeCount).toBe(0)
+
+    const closePromise = writer.close()
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(appendEvents).toHaveBeenCalledOnce()
+    expect(closeCount).toBe(0)
+
+    const resolvePersist = releasePersist
+    if (typeof resolvePersist === 'function') {
+      resolvePersist()
+    }
+    await closePromise
+
+    expect(closeCount).toBe(1)
+  })
+
+  it('batches publishes on the flush timer and preserves sequence order', async () => {
+    vi.useFakeTimers()
+    const persistedSeqs: number[] = []
+    appendEvents.mockImplementation(async (envelopes) => {
+      persistedSeqs.push(...envelopes.map((envelope) => envelope.seq))
+      return envelopes
+    })
+
+    const writer = new StreamWriter({
+      streamId: 'stream-1',
+      requestId: 'req-1',
+    })
+
+    const chunks: string[] = []
+    const controller = {
+      enqueue: vi.fn((value: Uint8Array) => {
+        chunks.push(decodeChunk(value))
+      }),
+      close: vi.fn(),
+    } as unknown as ReadableStreamDefaultController
+
+    writer.attach(controller)
+    await Promise.all([
+      writer.publish({
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'one' },
+      }),
+      writer.publish({
+        type: MothershipStreamV1EventType.text,
+        payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'two' },
+      }),
+    ])
+    expect(appendEvents).not.toHaveBeenCalled()
+
+    await vi.advanceTimersByTimeAsync(15)
+    await writer.close()
+
+    expect(persistedSeqs).toEqual([1, 2])
+    expect(appendEvents).toHaveBeenCalledWith([
+      expect.objectContaining({ seq: 1 }),
+      expect.objectContaining({ seq: 2 }),
+    ])
+    expect(chunks[0]).toContain('"seq":1')
+    expect(chunks[1]).toContain('"seq":2')
+  })
+
+  it('flush waits for persistence and surfaces failures', async () => {
+    appendEvents.mockRejectedValueOnce(new Error('redis down'))
+
+    const writer = new StreamWriter({
+      streamId: 'stream-1',
+      requestId: 'req-1',
+    })
+
+    writer.attach({
+      enqueue: vi.fn(),
+      close: vi.fn(),
+    } as unknown as ReadableStreamDefaultController)
+
+    await writer.publish({
+      type: MothershipStreamV1EventType.text,
+      payload: { channel: MothershipStreamV1TextChannel.assistant, text: 'boom' },
+    })
+
+    await expect(writer.flush()).rejects.toThrow('redis down')
+  })
+
+  it('persists synthetic preview events alongside contract events', async () => {
+    appendEvents.mockResolvedValue([])
+
+    const writer = new StreamWriter({
+      streamId: 'stream-1',
+      requestId: 'req-1',
+    })
+
+    const chunks: string[] = []
+    writer.attach({
+      enqueue: vi.fn((value: Uint8Array) => {
+        chunks.push(decodeChunk(value))
+      }),
+      close: vi.fn(),
+    } as unknown as ReadableStreamDefaultController)
+
+    await writer.publish({
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'preview-1',
+        toolName: 'workspace_file',
+        previewPhase: 'file_preview_start',
+      },
+    } satisfies StreamEvent)
+
+    await writer.flush()
+
+    expect(chunks[0]).toContain('"previewPhase":"file_preview_start"')
+    expect(appendEvents).toHaveBeenCalledWith([
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.tool,
+        payload: expect.objectContaining({
+          toolCallId: 'preview-1',
+          previewPhase: 'file_preview_start',
+        }),
+      }),
+    ])
+  })
+})
diff --git a/apps/sim/lib/copilot/request/session/writer.ts b/apps/sim/lib/copilot/request/session/writer.ts
new file mode 100644
index 00000000000..28527c15525
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/writer.ts
@@ -0,0 +1,199 @@
+import { createLogger } from '@sim/logger'
+import { MothershipStreamV1EventType } from '@/lib/copilot/generated/mothership-stream-v1'
+import { appendEvents } from './buffer'
+import type { PersistedStreamEventEnvelope } from './contract'
+import { createEvent } from './event'
+import { encodeSSEComment, encodeSSEEnvelope } from './sse'
+import type { StreamEvent } from './types'
+
+const logger = createLogger('StreamWriter')
+
+const DEFAULT_KEEPALIVE_MS = 15_000
+const DEFAULT_PERSIST_FLUSH_INTERVAL_MS = 15
+const DEFAULT_PERSIST_FLUSH_MAX_BATCH = 200
+
+export interface StreamWriterOptions {
+  streamId: string
+  chatId?: string
+  requestId: string
+  keepaliveMs?: number
+}
+
+export class StreamWriter {
+  private readonly streamId: string
+  private readonly chatId: string | undefined
+  private requestId: string
+  private readonly keepaliveMs: number
+  private readonly flushIntervalMs: number
+  private readonly flushMaxBatch: number
+  private readonly encoder: TextEncoder
+  private controller: ReadableStreamDefaultController | null = null
+  private keepaliveInterval: ReturnType<typeof setInterval> | null = null
+  private flushTimer: ReturnType<typeof setTimeout> | null = null
+  private _clientDisconnected = false
+  private _sawComplete = false
+  private nextSeq = 0
+  private pendingEnvelopes: PersistedStreamEventEnvelope[] = []
+  private persistenceTail: Promise<void> = Promise.resolve()
+  private lastPersistenceError: Error | null = null
+
+  constructor(options: StreamWriterOptions) {
+    this.streamId = options.streamId
+    this.chatId = options.chatId
+    this.requestId = options.requestId
+    this.keepaliveMs = options.keepaliveMs ?? DEFAULT_KEEPALIVE_MS
+    this.flushIntervalMs = DEFAULT_PERSIST_FLUSH_INTERVAL_MS
+    this.flushMaxBatch = DEFAULT_PERSIST_FLUSH_MAX_BATCH
+    this.encoder = new TextEncoder()
+  }
+
+  get clientDisconnected(): boolean {
+    return this._clientDisconnected
+  }
+
+  get sawComplete(): boolean {
+    return this._sawComplete
+  }
+
+  updateRequestId(id: string): void {
+    this.requestId = id
+  }
+
+  attach(controller: ReadableStreamDefaultController): void {
+    this.controller = controller
+  }
+
+  startKeepalive(): void {
+    this.keepaliveInterval = setInterval(() => {
+      if (this._clientDisconnected || !this.controller) return
+      try {
+        this.controller.enqueue(encodeSSEComment('keepalive'))
+      } catch (error) {
+        this._clientDisconnected = true
+        logger.warn('Keepalive enqueue failed, marking client disconnected', {
+          streamId: this.streamId,
+          requestId: this.requestId,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }, this.keepaliveMs)
+  }
+
+  stopKeepalive(): void {
+    if (this.keepaliveInterval) {
+      clearInterval(this.keepaliveInterval)
+      this.keepaliveInterval = null
+    }
+  }
+
+  publish(event: StreamEvent): void {
+    const envelope = this.createEnvelope(event)
+    this.enqueue(envelope)
+    this.queuePersistence(envelope)
+    if (event.type === MothershipStreamV1EventType.complete) {
+      this._sawComplete = true
+    }
+  }
+
+  markDisconnected(): void {
+    this._clientDisconnected = true
+  }
+
+  async flush(): Promise<void> {
+    this.flushPendingPersistence()
+    await this.persistenceTail
+    if (this.lastPersistenceError) {
+      const error = this.lastPersistenceError
+      this.lastPersistenceError = null
+      throw error
+    }
+  }
+
+  async close(): Promise<void> {
+    this.stopKeepalive()
+    this.clearFlushTimer()
+    await this.flush()
+    if (!this.controller) return
+    try {
+      this.controller.close()
+    } catch {
+      // Controller already closed
+    }
+    this.controller = null
+  }
+
+  private enqueue(envelope: PersistedStreamEventEnvelope): void {
+    if (this._clientDisconnected || !this.controller) return
+    try {
+      this.controller.enqueue(encodeSSEEnvelope(envelope))
+    } catch (error) {
+      this._clientDisconnected = true
+      logger.warn('Envelope enqueue failed, marking client disconnected', {
+        streamId: this.streamId,
+        requestId: this.requestId,
+        seq: envelope.seq,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  private createEnvelope(event: StreamEvent): PersistedStreamEventEnvelope {
+    const seq = ++this.nextSeq
+    return createEvent({
+      ...event,
+      streamId: this.streamId,
+      chatId: this.chatId,
+      cursor: String(seq),
+      seq,
+      requestId: this.requestId,
+    })
+  }
+
+  private queuePersistence(envelope: PersistedStreamEventEnvelope): void {
+    this.pendingEnvelopes.push(envelope)
+    if (this.pendingEnvelopes.length >= this.flushMaxBatch) {
+      this.flushPendingPersistence()
+      return
+    }
+    if (this.flushTimer || this.pendingEnvelopes.length === 0) {
+      return
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null
+      this.flushPendingPersistence()
+    }, this.flushIntervalMs)
+  }
+
+  private flushPendingPersistence(): void {
+    this.clearFlushTimer()
+    if (this.pendingEnvelopes.length === 0) {
+      return
+    }
+    const batch = this.pendingEnvelopes
+    this.pendingEnvelopes = []
+    this.persistenceTail = this.persistenceTail
+      .catch(() => undefined)
+      .then(() => appendEvents(batch))
+      .then(() => {
+        this.lastPersistenceError = null
+      })
+      .catch((error) => {
+        this.lastPersistenceError = error instanceof Error ? error : new Error(String(error))
+        logger.warn('Failed to persist stream envelope batch', {
+          streamId: this.streamId,
+          requestId: this.requestId,
+          batchSize: batch.length,
+          firstSeq: batch[0]?.seq,
+          lastSeq: batch[batch.length - 1]?.seq,
+          error: error instanceof Error ? error.message : String(error),
+        })
+      })
+  }
+
+  private clearFlushTimer(): void {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer)
+      this.flushTimer = null
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/sse-utils.ts b/apps/sim/lib/copilot/request/sse-utils.ts
new file mode 100644
index 00000000000..7c403b2fd51
--- /dev/null
+++ b/apps/sim/lib/copilot/request/sse-utils.ts
@@ -0,0 +1,68 @@
+import { STREAM_BUFFER_MAX_DEDUP_ENTRIES } from '@/lib/copilot/constants'
+import {
+  isToolCallStreamEvent,
+  isToolResultStreamEvent,
+  type ToolCallStreamEvent,
+  type ToolResultStreamEvent,
+} from '@/lib/copilot/request/session'
+import { TOOL_CALL_STATUS } from '@/lib/copilot/request/session/event'
+import type { StreamEvent } from '@/lib/copilot/request/types'
+
+/** Safely cast event.data to a record for property access. */
+export const asRecord = (data: unknown): Record<string, unknown> =>
+  (data && typeof data === 'object' && !Array.isArray(data) ? data : {}) as Record<string, unknown>
+
+/**
+ * In-memory tool event dedupe with bounded size.
+ *
+ * NOTE: Process-local only. In a multi-instance setup (e.g., ECS),
+ * each task maintains its own dedupe cache.
+ */
+const seenToolCalls = new Set<string>()
+const seenToolResults = new Set<string>()
+
+function addToSet(set: Set<string>, id: string): void {
+  if (set.size >= STREAM_BUFFER_MAX_DEDUP_ENTRIES) {
+    const first = set.values().next().value
+    if (first) set.delete(first)
+  }
+  set.add(id)
+}
+
+function getToolCallIdFromCallEvent(event: ToolCallStreamEvent): string {
+  return event.payload.toolCallId
+}
+
+function getToolCallIdFromResultEvent(event: ToolResultStreamEvent): string {
+  return event.payload.toolCallId
+}
+
+function markToolCallSeen(toolCallId: string): void {
+  addToSet(seenToolCalls, toolCallId)
+}
+
+function wasToolCallSeen(toolCallId: string): boolean {
+  return seenToolCalls.has(toolCallId)
+}
+
+export function markToolResultSeen(toolCallId: string): void {
+  addToSet(seenToolResults, toolCallId)
+}
+
+export function wasToolResultSeen(toolCallId: string): boolean {
+  return seenToolResults.has(toolCallId)
+}
+
+export function shouldSkipToolCallEvent(event: StreamEvent): boolean {
+  if (!isToolCallStreamEvent(event)) return false
+  if (event.payload.status === TOOL_CALL_STATUS.generating) return false
+  const toolCallId = getToolCallIdFromCallEvent(event)
+  if (event.payload.partial === true) return false
+  if (wasToolResultSeen(toolCallId) || wasToolCallSeen(toolCallId)) return true
+  markToolCallSeen(toolCallId)
+  return false
+}
+
+export function shouldSkipToolResultEvent(event: StreamEvent): boolean {
+  return isToolResultStreamEvent(event) && wasToolResultSeen(getToolCallIdFromResultEvent(event))
+}
diff --git a/apps/sim/lib/copilot/orchestrator/subagent.ts b/apps/sim/lib/copilot/request/subagent.ts
similarity index 76%
rename from apps/sim/lib/copilot/orchestrator/subagent.ts
rename to apps/sim/lib/copilot/request/subagent.ts
index 0fc6716bc6c..43f56abe120 100644
--- a/apps/sim/lib/copilot/orchestrator/subagent.ts
+++ b/apps/sim/lib/copilot/request/subagent.ts
@@ -1,17 +1,23 @@
 import { createLogger } from '@sim/logger'
 import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
-import { prepareExecutionContext } from '@/lib/copilot/orchestrator/tool-executor'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1SpanPayloadKind,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
+import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
+import { runStreamLoop } from '@/lib/copilot/request/go/stream'
 import type {
   ExecutionContext,
   OrchestratorOptions,
-  SSEEvent,
+  StreamEvent,
   StreamingContext,
   ToolCallSummary,
-} from '@/lib/copilot/orchestrator/types'
+} from '@/lib/copilot/request/types'
+import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
 import { env } from '@/lib/core/config/env'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { buildToolCallSummaries, createStreamingContext, runStreamLoop } from './stream/core'
 
 const logger = createLogger('CopilotSubagentOrchestrator')
 
@@ -72,23 +78,23 @@ export async function orchestrateSubagentStream(
       execContext,
       {
         ...options,
-        onBeforeDispatch: (event: SSEEvent, ctx: StreamingContext) => {
-          // Handle structured_result / subagent_result - subagent-specific.
-          if (event.type === 'structured_result' || event.type === 'subagent_result') {
-            structuredResult = normalizeStructuredResult(event.data)
+        interactive: false,
+        onBeforeDispatch: (event: StreamEvent, ctx: StreamingContext) => {
+          if (
+            event.type === MothershipStreamV1EventType.span &&
+            (event.payload.kind === MothershipStreamV1SpanPayloadKind.structured_result ||
+              event.payload.kind === MothershipStreamV1SpanPayloadKind.subagent_result)
+          ) {
+            structuredResult = normalizeStructuredResult(event.payload.data)
             ctx.streamComplete = true
-            return true // skip default dispatch
+            return true
           }
 
-          // For direct subagent calls, events may have the subagent field set
-          // but no subagent_start because this IS the top-level agent.
-          // Skip subagent routing for events where the subagent field matches
-          // the current agentId - these are top-level events.
-          if (event.subagent === agentId && !ctx.subAgentParentToolCallId) {
-            return false // let default dispatch handle it
+          if (event.scope?.agentId === agentId && !ctx.subAgentParentToolCallId) {
+            return false
           }
 
-          return false // let default dispatch handle it
+          return false
         },
       }
     )
diff --git a/apps/sim/lib/copilot/request/tool-call-state.ts b/apps/sim/lib/copilot/request/tool-call-state.ts
new file mode 100644
index 00000000000..70433429043
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tool-call-state.ts
@@ -0,0 +1,104 @@
+import {
+  MothershipStreamV1ToolOutcome,
+  type MothershipStreamV1ToolOutcome as TerminalToolCallStatus,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type { ToolCallState, ToolCallStateResult } from '@/lib/copilot/request/types'
+
+function hasOwnOutput(value: { output?: unknown }): value is { output: unknown } {
+  return Object.hasOwn(value, 'output')
+}
+
+export function isSuccessfulToolCallStatus(status: TerminalToolCallStatus): boolean {
+  return (
+    status === MothershipStreamV1ToolOutcome.success ||
+    status === MothershipStreamV1ToolOutcome.skipped
+  )
+}
+
+export function createToolCallStateResult(input: {
+  success: boolean
+  output?: unknown
+}): ToolCallStateResult {
+  return hasOwnOutput(input)
+    ? { success: input.success, output: input.output }
+    : { success: input.success }
+}
+
+export function getToolCallStateOutput(toolCall: Pick<ToolCallState, 'result'>): unknown {
+  if (!toolCall.result || !hasOwnOutput(toolCall.result)) {
+    return undefined
+  }
+
+  return toolCall.result.output
+}
+
+export function requireToolCallStateResult(
+  toolCall: Pick<ToolCallState, 'id' | 'status' | 'result'>
+): ToolCallStateResult {
+  if (toolCall.result) {
+    return toolCall.result
+  }
+
+  throw new Error(
+    `Terminal tool call ${toolCall.id} is missing a canonical result for status ${toolCall.status}`
+  )
+}
+
+export function requireToolCallError(
+  toolCall: Pick<ToolCallState, 'id' | 'status' | 'error'>
+): string {
+  if (typeof toolCall.error === 'string' && toolCall.error.length > 0) {
+    return toolCall.error
+  }
+
+  throw new Error(
+    `Terminal tool call ${toolCall.id} is missing a canonical error for status ${toolCall.status}`
+  )
+}
+
+export function getToolCallTerminalData(
+  toolCall: Pick<ToolCallState, 'id' | 'status' | 'result' | 'error'>
+): unknown {
+  const output = getToolCallStateOutput(toolCall)
+  if (output !== undefined) {
+    return output
+  }
+
+  if (
+    toolCall.status === MothershipStreamV1ToolOutcome.success ||
+    toolCall.status === MothershipStreamV1ToolOutcome.skipped
+  ) {
+    return undefined
+  }
+
+  return { error: requireToolCallError(toolCall) }
+}
+
+export function setTerminalToolCallState(
+  toolCall: ToolCallState,
+  input: {
+    status: TerminalToolCallStatus
+    output?: unknown
+    error?: string
+    endTime?: number
+  }
+): void {
+  const success = isSuccessfulToolCallStatus(input.status)
+  toolCall.status = input.status
+  toolCall.endTime = input.endTime ?? Date.now()
+  toolCall.result = createToolCallStateResult({
+    success,
+    ...(Object.hasOwn(input, 'output') ? { output: input.output } : {}),
+  })
+
+  if (success) {
+    toolCall.error = undefined
+    return
+  }
+
+  toolCall.error = requireToolCallError({
+    id: toolCall.id,
+    status: input.status,
+    error: input.error,
+  })
+}
diff --git a/apps/sim/lib/copilot/request/tools/billing.ts b/apps/sim/lib/copilot/request/tools/billing.ts
new file mode 100644
index 00000000000..2f4b0e2d7ac
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/billing.ts
@@ -0,0 +1,84 @@
+import { createLogger } from '@sim/logger'
+import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
+import { isPaid } from '@/lib/billing/plan-helpers'
+import {
+  MothershipStreamV1CompletionStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1TextChannel,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { sseHandlers } from '@/lib/copilot/request/handlers'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  StreamEvent,
+  StreamingContext,
+} from '@/lib/copilot/request/types'
+
+const logger = createLogger('CopilotBillingEffect')
+
+/**
+ * Handle a 402 billing-limit response from the Go backend.
+ *
+ * Determines whether the user needs a plan upgrade or a limit increase,
+ * then dispatches synthetic text + complete events through the handler chain
+ * so the client renders the upgrade prompt.
+ */
+export async function handleBillingLimitResponse(
+  userId: string,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options: OrchestratorOptions
+): Promise<void> {
+  let action = 'upgrade_plan'
+  let message = "You've reached your usage limit. Please upgrade your plan to continue."
+  try {
+    const sub = await getHighestPrioritySubscription(userId)
+    if (sub && isPaid(sub.plan)) {
+      action = 'increase_limit'
+      message =
+        "You've reached your usage limit for this billing period. Please increase your usage limit to continue."
+    }
+  } catch {
+    logger.warn('Failed to determine subscription plan, defaulting to upgrade_plan')
+  }
+
+  const upgradePayload = JSON.stringify({
+    reason: 'usage_limit',
+    action,
+    message,
+  })
+  const syntheticContent = `<usage_upgrade>${upgradePayload}</usage_upgrade>`
+
+  const syntheticEvents: StreamEvent[] = [
+    {
+      type: MothershipStreamV1EventType.text,
+      payload: {
+        channel: MothershipStreamV1TextChannel.assistant,
+        text: syntheticContent,
+      },
+    },
+    {
+      type: MothershipStreamV1EventType.complete,
+      payload: {
+        status: MothershipStreamV1CompletionStatus.complete,
+      },
+    },
+  ]
+
+  for (const event of syntheticEvents) {
+    try {
+      await options.onEvent?.(event)
+    } catch {
+      logger.warn('Failed to forward synthetic billing event', { type: event.type })
+    }
+
+    // TODO: Handler dispatch should move out of this effect — effects should be
+    // pure side-effect producers; event dispatch belongs in the stream loop or
+    // a dedicated dispatcher. Keeping here for now to preserve behavior.
+    const handler = sseHandlers[event.type]
+    if (handler) {
+      await handler(event, context, execContext, options)
+    }
+    if (context.streamComplete) break
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/client.ts b/apps/sim/lib/copilot/request/tools/client.ts
new file mode 100644
index 00000000000..43c42de6a8c
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/client.ts
@@ -0,0 +1,33 @@
+import {
+  ASYNC_TOOL_CONFIRMATION_STATUS,
+  type AsyncTerminalCompletionSnapshot,
+  isAsyncTerminalConfirmationStatus,
+} from '@/lib/copilot/async-runs/lifecycle'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import { waitForToolConfirmation } from '@/lib/copilot/persistence/tool-confirm'
+
+/**
+ * Wait for a client-executable workflow tool to report back.
+ *
+ * Current browser runtime outcomes are:
+ * - `success`, `error`, `cancelled`: the workflow finished in the browser
+ * - `background`: the browser detached on `pagehide`, so the server should stop
+ *   waiting for a foreground result
+ */
+export async function waitForToolCompletion(
+  toolCallId: string,
+  timeoutMs: number,
+  abortSignal?: AbortSignal
+): Promise<AsyncTerminalCompletionSnapshot | null> {
+  const decision = await waitForToolConfirmation(toolCallId, timeoutMs, abortSignal, {
+    acceptStatus: (status) =>
+      status === MothershipStreamV1ToolOutcome.success ||
+      status === MothershipStreamV1ToolOutcome.error ||
+      status === ASYNC_TOOL_CONFIRMATION_STATUS.background ||
+      status === MothershipStreamV1ToolOutcome.cancelled,
+  })
+  if (decision && isAsyncTerminalConfirmationStatus(decision.status)) {
+    return { ...decision, status: decision.status }
+  }
+  return null
+}
diff --git a/apps/sim/lib/copilot/request/tools/executor.ts b/apps/sim/lib/copilot/request/tools/executor.ts
new file mode 100644
index 00000000000..bc1cb26cde9
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/executor.ts
@@ -0,0 +1,582 @@
+import { createLogger } from '@sim/logger'
+import type {
+  AsyncCompletionEnvelope,
+  AsyncCompletionSignal,
+} from '@/lib/copilot/async-runs/lifecycle'
+import {
+  completeAsyncToolCall,
+  markAsyncToolRunning,
+  upsertAsyncToolCall,
+} from '@/lib/copilot/async-runs/repository'
+import {
+  MothershipStreamV1AsyncToolRecordStatus,
+  MothershipStreamV1EventType,
+  MothershipStreamV1ToolExecutor,
+  MothershipStreamV1ToolMode,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { CreateWorkflow } from '@/lib/copilot/generated/tool-catalog-v1'
+import { publishToolConfirmation } from '@/lib/copilot/persistence/tool-confirm'
+import { markToolResultSeen } from '@/lib/copilot/request/sse-utils'
+import {
+  getToolCallStateOutput,
+  getToolCallTerminalData,
+  requireToolCallError,
+  setTerminalToolCallState,
+} from '@/lib/copilot/request/tool-call-state'
+import { maybeWriteOutputToFile } from '@/lib/copilot/request/tools/files'
+import { handleResourceSideEffects } from '@/lib/copilot/request/tools/resources'
+import {
+  maybeWriteOutputToTable,
+  maybeWriteReadCsvToTable,
+} from '@/lib/copilot/request/tools/tables'
+import {
+  type ExecutionContext,
+  isTerminalToolCallStatus,
+  type OrchestratorOptions,
+  type StreamEvent,
+  type StreamingContext,
+  type ToolCallState,
+} from '@/lib/copilot/request/types'
+import { ensureHandlersRegistered, executeTool } from '@/lib/copilot/tool-executor'
+
+export { waitForToolCompletion } from '@/lib/copilot/request/tools/client'
+
+const logger = createLogger('CopilotSseToolExecution')
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function hasOutputValue(result: { output?: unknown } | undefined): result is { output: unknown } {
+  return result !== undefined && Object.hasOwn(result, 'output')
+}
+
+function buildCompletionSignal(input: {
+  status: AsyncCompletionSignal['status']
+  message?: string
+  data?: unknown
+}): AsyncCompletionSignal {
+  return {
+    status: input.status,
+    ...(input.message !== undefined ? { message: input.message } : {}),
+    ...(input.data !== undefined ? { data: input.data } : {}),
+  }
+}
+
+function getCreateWorkflowOutput(
+  output: unknown
+): { workflowId?: string; workspaceId?: string } | undefined {
+  if (!isRecord(output)) {
+    return undefined
+  }
+
+  const workflowId = typeof output.workflowId === 'string' ? output.workflowId : undefined
+  const workspaceId = typeof output.workspaceId === 'string' ? output.workspaceId : undefined
+  if (!workflowId && !workspaceId) {
+    return undefined
+  }
+
+  return {
+    ...(workflowId ? { workflowId } : {}),
+    ...(workspaceId ? { workspaceId } : {}),
+  }
+}
+
+export interface AsyncToolCompletion extends AsyncCompletionSignal {}
+
+function publishTerminalToolConfirmation(input: {
+  toolCallId: string
+  status: AsyncCompletionEnvelope['status']
+  message?: string
+  data?: unknown
+}): void {
+  publishToolConfirmation({
+    toolCallId: input.toolCallId,
+    status: input.status,
+    message: input.message,
+    data: input.data,
+    timestamp: new Date().toISOString(),
+  })
+}
+
+function abortRequested(
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options?: OrchestratorOptions
+): boolean {
+  return Boolean(
+    options?.abortSignal?.aborted || execContext.abortSignal?.aborted || context.wasAborted
+  )
+}
+
+function cancelledCompletion(message: string): AsyncToolCompletion {
+  return buildCompletionSignal({
+    status: MothershipStreamV1ToolOutcome.cancelled,
+    message,
+    data: { cancelled: true },
+  })
+}
+
+function terminalCompletionFromToolCall(toolCall: ToolCallState): AsyncToolCompletion {
+  if (toolCall.status === MothershipStreamV1ToolOutcome.cancelled) {
+    return cancelledCompletion(requireToolCallError(toolCall))
+  }
+
+  if (toolCall.status === MothershipStreamV1ToolOutcome.success) {
+    const data = getToolCallStateOutput(toolCall)
+    return buildCompletionSignal({
+      status: MothershipStreamV1ToolOutcome.success,
+      message: 'Tool completed',
+      ...(data !== undefined ? { data } : {}),
+    })
+  }
+
+  if (toolCall.status === MothershipStreamV1ToolOutcome.skipped) {
+    const data = getToolCallStateOutput(toolCall)
+    return buildCompletionSignal({
+      status: MothershipStreamV1ToolOutcome.success,
+      message: 'Tool skipped',
+      ...(data !== undefined ? { data } : {}),
+    })
+  }
+
+  const terminalErrorMessage = requireToolCallError(toolCall)
+  return buildCompletionSignal({
+    status: MothershipStreamV1ToolOutcome.error,
+    message: terminalErrorMessage,
+    data: getToolCallTerminalData(toolCall),
+  })
+}
+
+export async function executeToolAndReport(
+  toolCallId: string,
+  context: StreamingContext,
+  execContext: ExecutionContext,
+  options?: OrchestratorOptions
+): Promise<AsyncToolCompletion> {
+  const toolCall = context.toolCalls.get(toolCallId)
+  if (!toolCall)
+    return buildCompletionSignal({
+      status: MothershipStreamV1ToolOutcome.error,
+      message: 'Tool call not found',
+    })
+
+  if (toolCall.status === 'executing') {
+    return buildCompletionSignal({
+      status: MothershipStreamV1AsyncToolRecordStatus.running,
+      message: 'Tool already executing',
+    })
+  }
+  if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
+    return terminalCompletionFromToolCall(toolCall)
+  }
+
+  const markToolCallCancelled = (message: string) => {
+    setTerminalToolCallState(toolCall, {
+      status: MothershipStreamV1ToolOutcome.cancelled,
+      error: message,
+    })
+  }
+
+  if (abortRequested(context, execContext, options)) {
+    markToolCallCancelled('Request aborted before tool execution')
+    markToolResultSeen(toolCall.id)
+    await completeAsyncToolCall({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+      result: { cancelled: true },
+      error: 'Request aborted before tool execution',
+    }).catch((err) => {
+      logger.warn('Failed to persist async tool status', {
+        toolCallId: toolCall.id,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    })
+    publishTerminalToolConfirmation({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1ToolOutcome.cancelled,
+      message: 'Request aborted before tool execution',
+      data: { cancelled: true },
+    })
+    return cancelledCompletion('Request aborted before tool execution')
+  }
+
+  toolCall.status = 'executing'
+  await upsertAsyncToolCall({
+    runId: context.runId,
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+    args: toolCall.params,
+  }).catch((err) => {
+    logger.warn('Failed to persist async tool row before execution', {
+      toolCallId: toolCall.id,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  })
+  await markAsyncToolRunning(toolCall.id, 'sim-stream').catch((err) => {
+    logger.warn('Failed to mark async tool running', {
+      toolCallId: toolCall.id,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  })
+
+  if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
+    return terminalCompletionFromToolCall(toolCall)
+  }
+
+  const argsPreview = toolCall.params ? JSON.stringify(toolCall.params).slice(0, 200) : undefined
+  const toolSpan = context.trace.startSpan(toolCall.name, 'tool.execute', {
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+    argsPreview,
+    abortSignalAborted: execContext.abortSignal?.aborted ?? false,
+  })
+
+  const endToolSpan = (
+    status: string,
+    detail?: { error?: string; cancelReason?: string; resultSuccess?: boolean }
+  ) => {
+    const abortDetail: Record<string, unknown> = {}
+    if (execContext.abortSignal?.aborted) {
+      abortDetail.abortSignalAborted = true
+      abortDetail.abortReason = String(execContext.abortSignal.reason ?? 'unknown')
+    }
+    if (options?.abortSignal?.aborted) {
+      abortDetail.optionsAbortReason = String(options.abortSignal.reason ?? 'unknown')
+    }
+    if (context.wasAborted) {
+      abortDetail.wasAborted = true
+    }
+    toolSpan.attributes = { ...toolSpan.attributes, ...abortDetail, ...detail }
+    context.trace.endSpan(toolSpan, status)
+  }
+  const endToolSpanFromTerminalState = () => {
+    const terminalStatus =
+      toolCall.status === MothershipStreamV1ToolOutcome.cancelled
+        ? 'cancelled'
+        : toolCall.status === MothershipStreamV1ToolOutcome.success ||
+            toolCall.status === MothershipStreamV1ToolOutcome.skipped
+          ? 'ok'
+          : 'error'
+    endToolSpan(terminalStatus, {
+      resultSuccess: toolCall.status === MothershipStreamV1ToolOutcome.success,
+      ...(toolCall.error ? { error: toolCall.error } : {}),
+    })
+  }
+
+  logger.info('Tool execution started', {
+    toolCallId: toolCall.id,
+    toolName: toolCall.name,
+  })
+
+  try {
+    ensureHandlersRegistered()
+    let result = await executeTool(toolCall.name, toolCall.params || {}, execContext)
+    if (toolCall.endTime || isTerminalToolCallStatus(toolCall.status)) {
+      endToolSpanFromTerminalState()
+      return terminalCompletionFromToolCall(toolCall)
+    }
+    if (abortRequested(context, execContext, options)) {
+      markToolCallCancelled('Request aborted during tool execution')
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool execution',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool execution',
+        data: { cancelled: true },
+      })
+      endToolSpan('cancelled', {
+        cancelReason: 'abort_during_execution',
+        error: result.success === false ? result.error : undefined,
+      })
+      return cancelledCompletion('Request aborted during tool execution')
+    }
+    result = await maybeWriteOutputToFile(toolCall.name, toolCall.params, result, execContext)
+    if (abortRequested(context, execContext, options)) {
+      markToolCallCancelled('Request aborted during tool post-processing')
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool post-processing',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool post-processing',
+        data: { cancelled: true },
+      })
+      endToolSpan('cancelled', { cancelReason: 'abort_during_post_processing_file' })
+      return cancelledCompletion('Request aborted during tool post-processing')
+    }
+    result = await maybeWriteOutputToTable(toolCall.name, toolCall.params, result, execContext)
+    if (abortRequested(context, execContext, options)) {
+      markToolCallCancelled('Request aborted during tool post-processing')
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool post-processing',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool post-processing',
+        data: { cancelled: true },
+      })
+      endToolSpan('cancelled', { cancelReason: 'abort_during_post_processing_table' })
+      return cancelledCompletion('Request aborted during tool post-processing')
+    }
+    result = await maybeWriteReadCsvToTable(toolCall.name, toolCall.params, result, execContext)
+    if (abortRequested(context, execContext, options)) {
+      markToolCallCancelled('Request aborted during tool post-processing')
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool post-processing',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool post-processing',
+        data: { cancelled: true },
+      })
+      endToolSpan('cancelled', { cancelReason: 'abort_during_post_processing_csv' })
+      return cancelledCompletion('Request aborted during tool post-processing')
+    }
+    setTerminalToolCallState(toolCall, {
+      status: result.success
+        ? MothershipStreamV1ToolOutcome.success
+        : MothershipStreamV1ToolOutcome.error,
+      ...(hasOutputValue(result) ? { output: result.output } : {}),
+      ...(result.success ? {} : { error: result.error || 'Tool failed' }),
+    })
+
+    if (result.success) {
+      const raw = result.output
+      const preview =
+        typeof raw === 'string'
+          ? raw.slice(0, 200)
+          : raw && typeof raw === 'object'
+            ? JSON.stringify(raw).slice(0, 200)
+            : undefined
+      logger.info('Tool execution succeeded', {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        outputPreview: preview,
+      })
+    } else {
+      logger.warn('Tool execution failed', {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        error: result.error,
+        params: toolCall.params,
+      })
+    }
+
+    // If create_workflow was successful, update the execution context with the new workflowId.
+    // This ensures subsequent tools in the same stream have access to the workflowId.
+    const createWorkflowOutput = getCreateWorkflowOutput(result.output)
+    if (
+      toolCall.name === CreateWorkflow.id &&
+      result.success &&
+      createWorkflowOutput?.workflowId &&
+      !execContext.workflowId
+    ) {
+      execContext.workflowId = createWorkflowOutput.workflowId
+      if (createWorkflowOutput.workspaceId) {
+        execContext.workspaceId = createWorkflowOutput.workspaceId
+      }
+    }
+
+    const terminalStatus = result.success
+      ? MothershipStreamV1ToolOutcome.success
+      : MothershipStreamV1ToolOutcome.error
+    const terminalMessage = result.success ? 'Tool completed' : requireToolCallError(toolCall)
+    const terminalData = getToolCallTerminalData(toolCall)
+
+    markToolResultSeen(toolCall.id)
+    await completeAsyncToolCall({
+      toolCallId: toolCall.id,
+      status: result.success
+        ? MothershipStreamV1AsyncToolRecordStatus.completed
+        : MothershipStreamV1AsyncToolRecordStatus.failed,
+      ...(terminalData !== undefined ? { result: terminalData } : {}),
+      error: result.success ? null : terminalMessage,
+    }).catch((err) => {
+      logger.warn('Failed to persist async tool completion', {
+        toolCallId: toolCall.id,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    })
+    publishTerminalToolConfirmation({
+      toolCallId: toolCall.id,
+      status: terminalStatus,
+      message: terminalMessage,
+      ...(terminalData !== undefined ? { data: terminalData } : {}),
+    })
+
+    if (abortRequested(context, execContext, options)) {
+      markToolCallCancelled('Request aborted before tool result delivery')
+      endToolSpan('cancelled', { cancelReason: 'abort_before_tool_result_delivery' })
+      return cancelledCompletion('Request aborted before tool result delivery')
+    }
+
+    // Fire-and-forget: notify the copilot backend that the tool completed.
+    // IMPORTANT: We must NOT await this — the Go backend may block on the
+    const resultEvent: StreamEvent = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.result,
+        success: result.success,
+        output: result.output,
+        ...(result.success
+          ? { status: MothershipStreamV1ToolOutcome.success }
+          : { status: MothershipStreamV1ToolOutcome.error }),
+      },
+    }
+    await options?.onEvent?.(resultEvent)
+
+    if (abortRequested(context, execContext, options)) {
+      markToolCallCancelled('Request aborted before resource persistence')
+      endToolSpan('cancelled', { cancelReason: 'abort_before_resource_persistence' })
+      return cancelledCompletion('Request aborted before resource persistence')
+    }
+
+    if (result.success && execContext.chatId && !abortRequested(context, execContext, options)) {
+      await handleResourceSideEffects(
+        toolCall.name,
+        toolCall.params,
+        result,
+        execContext.chatId,
+        options?.onEvent,
+        () => abortRequested(context, execContext, options)
+      )
+    }
+    endToolSpan(result.success ? 'ok' : 'error', {
+      resultSuccess: result.success,
+      ...(result.success ? {} : { error: terminalMessage }),
+    })
+    return buildCompletionSignal({
+      status: terminalStatus,
+      message: terminalMessage,
+      ...(terminalData !== undefined ? { data: terminalData } : {}),
+    })
+  } catch (error) {
+    const thrownMessage = error instanceof Error ? error.message : String(error)
+    if (abortRequested(context, execContext, options)) {
+      markToolCallCancelled('Request aborted during tool execution')
+      markToolResultSeen(toolCall.id)
+      await completeAsyncToolCall({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1AsyncToolRecordStatus.cancelled,
+        result: { cancelled: true },
+        error: 'Request aborted during tool execution',
+      }).catch((err) => {
+        logger.warn('Failed to persist async tool status', {
+          toolCallId: toolCall.id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+      publishTerminalToolConfirmation({
+        toolCallId: toolCall.id,
+        status: MothershipStreamV1ToolOutcome.cancelled,
+        message: 'Request aborted during tool execution',
+        data: { cancelled: true },
+      })
+      endToolSpan('cancelled', {
+        cancelReason: 'abort_during_execution_catch',
+        error: thrownMessage,
+      })
+      return cancelledCompletion('Request aborted during tool execution')
+    }
+    setTerminalToolCallState(toolCall, {
+      status: MothershipStreamV1ToolOutcome.error,
+      error: thrownMessage,
+    })
+
+    logger.error('Tool execution threw', {
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      error: toolCall.error,
+      params: toolCall.params,
+    })
+
+    markToolResultSeen(toolCall.id)
+    await completeAsyncToolCall({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1AsyncToolRecordStatus.failed,
+      result: { error: toolCall.error },
+      error: toolCall.error,
+    }).catch((err) => {
+      logger.warn('Failed to persist async tool error', {
+        toolCallId: toolCall.id,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    })
+    publishTerminalToolConfirmation({
+      toolCallId: toolCall.id,
+      status: MothershipStreamV1ToolOutcome.error,
+      message: toolCall.error,
+      data: { error: toolCall.error },
+    })
+
+    const errorEvent: StreamEvent = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        executor: MothershipStreamV1ToolExecutor.sim,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.result,
+        status: MothershipStreamV1ToolOutcome.error,
+        success: false,
+        error: toolCall.error,
+        output: { error: toolCall.error },
+      },
+    }
+    await options?.onEvent?.(errorEvent)
+    endToolSpan('error', { error: thrownMessage })
+    return buildCompletionSignal({
+      status: MothershipStreamV1ToolOutcome.error,
+      message: toolCall.error,
+      data: { error: toolCall.error },
+    })
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/files.ts b/apps/sim/lib/copilot/request/tools/files.ts
new file mode 100644
index 00000000000..64bb4bf6a1d
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/files.ts
@@ -0,0 +1,200 @@
+import { createLogger } from '@sim/logger'
+import { FunctionExecute, UserTable } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { uploadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const logger = createLogger('CopilotToolResultFiles')
+
+export const OUTPUT_PATH_TOOLS: Set<string> = new Set([FunctionExecute.id, UserTable.id])
+
+type OutputFormat = 'json' | 'csv' | 'txt' | 'md' | 'html'
+
+export const EXT_TO_FORMAT: Record<string, OutputFormat> = {
+  '.json': 'json',
+  '.csv': 'csv',
+  '.txt': 'txt',
+  '.md': 'md',
+  '.html': 'html',
+}
+
+export const FORMAT_TO_CONTENT_TYPE: Record<OutputFormat, string> = {
+  json: 'application/json',
+  csv: 'text/csv',
+  txt: 'text/plain',
+  md: 'text/markdown',
+  html: 'text/html',
+}
+
+/**
+ * Try to pull a flat array of row-objects out of the various shapes that
+ * `function_execute` and `user_table` can return.
+ */
+export function extractTabularData(output: unknown): Record<string, unknown>[] | null {
+  if (!output || typeof output !== 'object') return null
+
+  if (Array.isArray(output)) {
+    if (output.length > 0 && typeof output[0] === 'object' && output[0] !== null) {
+      return output as Record<string, unknown>[]
+    }
+    return null
+  }
+
+  const obj = output as Record<string, unknown>
+
+  // function_execute shape: { result: [...], stdout: "..." }
+  if (Array.isArray(obj.result)) {
+    const rows = obj.result
+    if (rows.length > 0 && typeof rows[0] === 'object' && rows[0] !== null) {
+      return rows as Record<string, unknown>[]
+    }
+  }
+
+  // user_table query_rows shape: { data: { rows: [{ data: {...} }], totalCount } }
+  if (obj.data && typeof obj.data === 'object' && !Array.isArray(obj.data)) {
+    const data = obj.data as Record<string, unknown>
+    if (Array.isArray(data.rows) && data.rows.length > 0) {
+      const rows = data.rows as Record<string, unknown>[]
+      if (typeof rows[0].data === 'object' && rows[0].data !== null) {
+        return rows.map((r) => r.data as Record<string, unknown>)
+      }
+      return rows
+    }
+  }
+
+  return null
+}
+
+export function escapeCsvValue(value: unknown): string {
+  if (value === null || value === undefined) return ''
+  const str = typeof value === 'object' ? JSON.stringify(value) : String(value)
+  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r')) {
+    return `"${str.replace(/"/g, '""')}"`
+  }
+  return str
+}
+
+export function convertRowsToCsv(rows: Record<string, unknown>[]): string {
+  if (rows.length === 0) return ''
+
+  const headerSet = new Set<string>()
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      headerSet.add(key)
+    }
+  }
+  const headers = [...headerSet]
+
+  const lines = [headers.map(escapeCsvValue).join(',')]
+  for (const row of rows) {
+    lines.push(headers.map((h) => escapeCsvValue(row[h])).join(','))
+  }
+  return lines.join('\n')
+}
+
+export function normalizeOutputWorkspaceFileName(outputPath: string): string {
+  const trimmed = outputPath.trim().replace(/^\/+/, '')
+  const withoutPrefix = trimmed.startsWith('files/') ? trimmed.slice('files/'.length) : trimmed
+  if (!withoutPrefix) {
+    throw new Error('outputPath must include a file name, e.g. "files/result.json"')
+  }
+  if (withoutPrefix.includes('/')) {
+    throw new Error(
+      'outputPath must target a flat workspace file, e.g. "files/result.json". Nested paths like "files/reports/result.json" are not supported.'
+    )
+  }
+  return withoutPrefix
+}
+
+export function resolveOutputFormat(fileName: string, explicit?: string): OutputFormat {
+  if (explicit && explicit in FORMAT_TO_CONTENT_TYPE) return explicit as OutputFormat
+  const ext = fileName.slice(fileName.lastIndexOf('.')).toLowerCase()
+  return EXT_TO_FORMAT[ext] ?? 'json'
+}
+
+export function serializeOutputForFile(output: unknown, format: OutputFormat): string {
+  if (typeof output === 'string') return output
+
+  if (format === 'csv') {
+    const rows = extractTabularData(output)
+    if (rows && rows.length > 0) {
+      return convertRowsToCsv(rows)
+    }
+  }
+
+  return JSON.stringify(output, null, 2)
+}
+
+export async function maybeWriteOutputToFile(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  if (!result.success || !result.output) return result
+  if (!OUTPUT_PATH_TOOLS.has(toolName)) return result
+  if (!context.workspaceId || !context.userId) return result
+
+  const args = params?.args as Record<string, unknown> | undefined
+  const outputPath =
+    (params?.outputPath as string | undefined) ?? (args?.outputPath as string | undefined)
+  if (!outputPath) return result
+  const outputSandboxPath =
+    (params?.outputSandboxPath as string | undefined) ??
+    (args?.outputSandboxPath as string | undefined)
+  if (toolName === FunctionExecute.id && outputSandboxPath) return result
+
+  const explicitFormat =
+    (params?.outputFormat as string | undefined) ?? (args?.outputFormat as string | undefined)
+
+  try {
+    const fileName = normalizeOutputWorkspaceFileName(outputPath)
+    const format = resolveOutputFormat(fileName, explicitFormat)
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    const content = serializeOutputForFile(result.output, format)
+    const contentType = FORMAT_TO_CONTENT_TYPE[format]
+
+    const buffer = Buffer.from(content, 'utf-8')
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    const uploaded = await uploadWorkspaceFile(
+      context.workspaceId,
+      context.userId,
+      buffer,
+      fileName,
+      contentType
+    )
+
+    logger.info('Tool output written to file', {
+      toolName,
+      fileName,
+      size: buffer.length,
+      fileId: uploaded.id,
+    })
+
+    return {
+      success: true,
+      output: {
+        message: `Output written to files/${fileName} (${buffer.length} bytes)`,
+        fileId: uploaded.id,
+        fileName,
+        size: buffer.length,
+        downloadUrl: uploaded.url,
+      },
+      resources: [{ type: 'file', id: uploaded.id, title: fileName }],
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    logger.warn('Failed to write tool output to file', {
+      toolName,
+      outputPath,
+      error: message,
+    })
+    return {
+      success: false,
+      error: `Failed to write output file: ${message}`,
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/resources.ts b/apps/sim/lib/copilot/request/tools/resources.ts
new file mode 100644
index 00000000000..b14f0caf79e
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/resources.ts
@@ -0,0 +1,91 @@
+import { createLogger } from '@sim/logger'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1ResourceOp,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent, ToolCallResult } from '@/lib/copilot/request/types'
+import {
+  extractDeletedResourcesFromToolResult,
+  extractResourcesFromToolResult,
+  hasDeleteCapability,
+  isResourceToolName,
+  persistChatResources,
+  removeChatResources,
+} from '@/lib/copilot/resources/persistence'
+
+const logger = createLogger('CopilotResourceEffects')
+
+/**
+ * Persist and emit resource events after a successful tool execution.
+ *
+ * Handles both creation/upsert and deletion of chat resources depending on
+ * the tool's capabilities and output shape.
+ */
+export async function handleResourceSideEffects(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  chatId: string,
+  onEvent: ((event: StreamEvent) => void | Promise<void>) | undefined,
+  isAborted: () => boolean
+): Promise<void> {
+  let isDeleteOp = false
+
+  if (hasDeleteCapability(toolName)) {
+    const deleted = extractDeletedResourcesFromToolResult(toolName, params, result.output)
+    if (deleted.length > 0) {
+      isDeleteOp = true
+      removeChatResources(chatId, deleted).catch((err) => {
+        logger.warn('Failed to remove chat resources after deletion', {
+          chatId,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+
+      for (const resource of deleted) {
+        if (isAborted()) break
+        await onEvent?.({
+          type: MothershipStreamV1EventType.resource,
+          payload: {
+            op: MothershipStreamV1ResourceOp.remove,
+            resource: { type: resource.type, id: resource.id, title: resource.title },
+          },
+        })
+      }
+    }
+  }
+
+  if (!isDeleteOp && !isAborted()) {
+    const resources =
+      result.resources && result.resources.length > 0
+        ? result.resources
+        : isResourceToolName(toolName)
+          ? extractResourcesFromToolResult(toolName, params, result.output)
+          : []
+
+    if (resources.length > 0) {
+      logger.info('[file-stream-server] Emitting resource upsert events', {
+        toolName,
+        chatId,
+        resources: resources.map((r) => ({ type: r.type, id: r.id, title: r.title })),
+      })
+      persistChatResources(chatId, resources).catch((err) => {
+        logger.warn('Failed to persist chat resources', {
+          chatId,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      })
+
+      for (const resource of resources) {
+        if (isAborted()) break
+        await onEvent?.({
+          type: MothershipStreamV1EventType.resource,
+          payload: {
+            op: MothershipStreamV1ResourceOp.upsert,
+            resource: { type: resource.type, id: resource.id, title: resource.title },
+          },
+        })
+      }
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/tools/tables.ts b/apps/sim/lib/copilot/request/tools/tables.ts
new file mode 100644
index 00000000000..89e0a5c19f0
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/tables.ts
@@ -0,0 +1,248 @@
+import { db } from '@sim/db'
+import { userTableRows } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { parse as csvParse } from 'csv-parse/sync'
+import { eq } from 'drizzle-orm'
+import { FunctionExecute, Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { getTableById } from '@/lib/table/service'
+
+const logger = createLogger('CopilotToolResultTables')
+
+const MAX_OUTPUT_TABLE_ROWS = 10_000
+const BATCH_CHUNK_SIZE = 500
+
+export async function maybeWriteOutputToTable(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  if (toolName !== FunctionExecute.id) return result
+  if (!result.success || !result.output) return result
+  if (!context.workspaceId || !context.userId) return result
+
+  const outputTable = params?.outputTable as string | undefined
+  if (!outputTable) return result
+
+  try {
+    const table = await getTableById(outputTable)
+    if (!table) {
+      return {
+        success: false,
+        error: `Table "${outputTable}" not found`,
+      }
+    }
+
+    const rawOutput = result.output
+    let rows: Array<Record<string, unknown>>
+
+    if (rawOutput && typeof rawOutput === 'object' && 'result' in rawOutput) {
+      const inner = (rawOutput as Record<string, unknown>).result
+      if (Array.isArray(inner)) {
+        rows = inner
+      } else {
+        return {
+          success: false,
+          error: 'outputTable requires the code to return an array of objects',
+        }
+      }
+    } else if (Array.isArray(rawOutput)) {
+      rows = rawOutput
+    } else {
+      return {
+        success: false,
+        error: 'outputTable requires the code to return an array of objects',
+      }
+    }
+
+    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
+      return {
+        success: false,
+        error: `outputTable row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
+      }
+    }
+
+    if (rows.length === 0) {
+      return {
+        success: false,
+        error: 'outputTable requires at least one row — code returned an empty array',
+      }
+    }
+
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    await db.transaction(async (tx) => {
+      if (context.abortSignal?.aborted) {
+        throw new Error('Request aborted before tool mutation could be applied')
+      }
+      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
+
+      const now = new Date()
+      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
+        if (context.abortSignal?.aborted) {
+          throw new Error('Request aborted before tool mutation could be applied')
+        }
+        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
+        const values = chunk.map((rowData, j) => ({
+          id: `row_${crypto.randomUUID().replace(/-/g, '')}`,
+          tableId: outputTable,
+          workspaceId: context.workspaceId!,
+          data: rowData,
+          position: i + j,
+          createdAt: now,
+          updatedAt: now,
+          createdBy: context.userId,
+        }))
+        await tx.insert(userTableRows).values(values)
+      }
+    })
+
+    logger.info('Tool output written to table', {
+      toolName,
+      tableId: outputTable,
+      rowCount: rows.length,
+    })
+
+    return {
+      success: true,
+      output: {
+        message: `Wrote ${rows.length} rows to table ${outputTable}`,
+        tableId: outputTable,
+        rowCount: rows.length,
+      },
+    }
+  } catch (err) {
+    logger.warn('Failed to write tool output to table', {
+      toolName,
+      outputTable,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return {
+      success: false,
+      error: `Failed to write to table: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}
+
+export async function maybeWriteReadCsvToTable(
+  toolName: string,
+  params: Record<string, unknown> | undefined,
+  result: ToolCallResult,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  if (toolName !== ReadTool.id) return result
+  if (!result.success || !result.output) return result
+  if (!context.workspaceId || !context.userId) return result
+
+  const outputTable = params?.outputTable as string | undefined
+  if (!outputTable) return result
+
+  try {
+    const table = await getTableById(outputTable)
+    if (!table) {
+      return { success: false, error: `Table "${outputTable}" not found` }
+    }
+
+    const output = result.output as Record<string, unknown>
+    const content = (output.content as string) || ''
+    if (!content.trim()) {
+      return { success: false, error: 'File has no content to import into table' }
+    }
+
+    const filePath = (params?.path as string) || ''
+    const ext = filePath.split('.').pop()?.toLowerCase()
+
+    let rows: Record<string, unknown>[]
+
+    if (ext === 'json') {
+      const parsed = JSON.parse(content)
+      if (!Array.isArray(parsed)) {
+        return {
+          success: false,
+          error: 'JSON file must contain an array of objects for table import',
+        }
+      }
+      rows = parsed
+    } else {
+      rows = csvParse(content, {
+        columns: true,
+        skip_empty_lines: true,
+        trim: true,
+        relax_column_count: true,
+        relax_quotes: true,
+        skip_records_with_error: true,
+        cast: false,
+      }) as Record<string, unknown>[]
+    }
+
+    if (rows.length === 0) {
+      return { success: false, error: 'File has no data rows to import' }
+    }
+
+    if (rows.length > MAX_OUTPUT_TABLE_ROWS) {
+      return {
+        success: false,
+        error: `Row limit exceeded: got ${rows.length}, max is ${MAX_OUTPUT_TABLE_ROWS}`,
+      }
+    }
+
+    if (context.abortSignal?.aborted) {
+      throw new Error('Request aborted before tool mutation could be applied')
+    }
+    await db.transaction(async (tx) => {
+      if (context.abortSignal?.aborted) {
+        throw new Error('Request aborted before tool mutation could be applied')
+      }
+      await tx.delete(userTableRows).where(eq(userTableRows.tableId, outputTable))
+
+      const now = new Date()
+      for (let i = 0; i < rows.length; i += BATCH_CHUNK_SIZE) {
+        if (context.abortSignal?.aborted) {
+          throw new Error('Request aborted before tool mutation could be applied')
+        }
+        const chunk = rows.slice(i, i + BATCH_CHUNK_SIZE)
+        const values = chunk.map((rowData, j) => ({
+          id: `row_${crypto.randomUUID().replace(/-/g, '')}`,
+          tableId: outputTable,
+          workspaceId: context.workspaceId!,
+          data: rowData,
+          position: i + j,
+          createdAt: now,
+          updatedAt: now,
+          createdBy: context.userId,
+        }))
+        await tx.insert(userTableRows).values(values)
+      }
+    })
+
+    logger.info('Read output written to table', {
+      toolName,
+      tableId: outputTable,
+      tableName: table.name,
+      rowCount: rows.length,
+      filePath,
+    })
+
+    return {
+      success: true,
+      output: {
+        message: `Imported ${rows.length} rows from "${filePath}" into table "${table.name}"`,
+        tableId: outputTable,
+        tableName: table.name,
+        rowCount: rows.length,
+      },
+    }
+  } catch (err) {
+    logger.warn('Failed to write read output to table', {
+      toolName,
+      outputTable,
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return {
+      success: false,
+      error: `Failed to import into table: ${err instanceof Error ? err.message : String(err)}`,
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/request/trace.ts b/apps/sim/lib/copilot/request/trace.ts
new file mode 100644
index 00000000000..8f74f743762
--- /dev/null
+++ b/apps/sim/lib/copilot/request/trace.ts
@@ -0,0 +1,128 @@
+import { createLogger } from '@sim/logger'
+import { SIM_AGENT_API_URL } from '@/lib/copilot/constants'
+import {
+  type RequestTraceV1CostSummary,
+  RequestTraceV1Outcome,
+  type RequestTraceV1SimReport,
+  type RequestTraceV1Span,
+  RequestTraceV1SpanSource,
+  RequestTraceV1SpanStatus,
+  type RequestTraceV1UsageSummary,
+} from '@/lib/copilot/generated/request-trace-v1'
+import { env } from '@/lib/core/config/env'
+
+const logger = createLogger('RequestTrace')
+
+export class TraceCollector {
+  private readonly spans: RequestTraceV1Span[] = []
+  private readonly startMs = Date.now()
+  private goTraceId?: string
+  private activeSpan?: RequestTraceV1Span
+
+  startSpan(
+    name: string,
+    kind: string,
+    attributes?: Record<string, unknown>,
+    parent?: RequestTraceV1Span
+  ): RequestTraceV1Span {
+    const startMs = Date.now()
+    const span: RequestTraceV1Span = {
+      name,
+      kind,
+      startMs,
+      endMs: startMs,
+      durationMs: 0,
+      status: RequestTraceV1SpanStatus.ok,
+      source: RequestTraceV1SpanSource.sim,
+      ...(parent
+        ? { parentName: parent.name }
+        : this.activeSpan
+          ? { parentName: this.activeSpan.name }
+          : {}),
+      ...(attributes && Object.keys(attributes).length > 0 ? { attributes } : {}),
+    }
+    this.spans.push(span)
+    return span
+  }
+
+  endSpan(
+    span: RequestTraceV1Span,
+    status: RequestTraceV1SpanStatus | string = RequestTraceV1SpanStatus.ok
+  ): void {
+    span.endMs = Date.now()
+    span.durationMs = span.endMs - span.startMs
+    span.status = status as RequestTraceV1SpanStatus
+  }
+
+  setActiveSpan(span: RequestTraceV1Span | undefined): void {
+    this.activeSpan = span
+  }
+
+  setGoTraceId(id: string): void {
+    if (!this.goTraceId && id) {
+      this.goTraceId = id
+    }
+  }
+
+  build(params: {
+    outcome: RequestTraceV1Outcome
+    simRequestId: string
+    streamId?: string
+    chatId?: string
+    runId?: string
+    executionId?: string
+    usage?: { prompt: number; completion: number }
+    cost?: { input: number; output: number; total: number }
+  }): RequestTraceV1SimReport {
+    const endMs = Date.now()
+    const usage: RequestTraceV1UsageSummary | undefined = params.usage
+      ? {
+          inputTokens: params.usage.prompt,
+          outputTokens: params.usage.completion,
+        }
+      : undefined
+
+    const cost: RequestTraceV1CostSummary | undefined = params.cost
+      ? {
+          rawTotalCost: params.cost.total,
+          billedTotalCost: params.cost.total,
+        }
+      : undefined
+
+    return {
+      simRequestId: params.simRequestId,
+      goTraceId: this.goTraceId,
+      streamId: params.streamId,
+      chatId: params.chatId,
+      runId: params.runId,
+      executionId: params.executionId,
+      startMs: this.startMs,
+      endMs,
+      durationMs: endMs - this.startMs,
+      outcome: params.outcome,
+      usage,
+      cost,
+      spans: this.spans,
+    }
+  }
+}
+
+export async function reportTrace(trace: RequestTraceV1SimReport): Promise<void> {
+  const response = await fetch(`${SIM_AGENT_API_URL}/api/traces`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+    },
+    body: JSON.stringify(trace),
+  })
+
+  if (!response.ok) {
+    logger.warn('Failed to report trace', {
+      status: response.status,
+      simRequestId: trace.simRequestId,
+    })
+  }
+}
+
+export { RequestTraceV1Outcome, RequestTraceV1SpanStatus }
diff --git a/apps/sim/lib/copilot/orchestrator/types.ts b/apps/sim/lib/copilot/request/types.ts
similarity index 50%
rename from apps/sim/lib/copilot/orchestrator/types.ts
rename to apps/sim/lib/copilot/request/types.ts
index b5a9e412f8e..f4ef77ba7d3 100644
--- a/apps/sim/lib/copilot/orchestrator/types.ts
+++ b/apps/sim/lib/copilot/request/types.ts
@@ -1,71 +1,17 @@
-import type { MothershipResource } from '@/lib/copilot/resource-types'
-
-export type SSEEventType =
-  | 'chat_id'
-  | 'request_id'
-  | 'title_updated'
-  | 'content'
-  | 'reasoning'
-  | 'tool_call'
-  | 'tool_call_delta'
-  | 'tool_generating'
-  | 'tool_result'
-  | 'tool_error'
-  | 'resource_added'
-  | 'resource_deleted'
-  | 'subagent_start'
-  | 'subagent_end'
-  | 'structured_result'
-  | 'subagent_result'
-  | 'done'
-  | 'error'
-  | 'start'
-
-export interface SSEEvent {
-  type: SSEEventType
-  /** Authoritative tool call state set by the server */
-  state?: string
-  data?: Record<string, unknown>
-  /** Parent agent that produced this event */
-  agent?: string
-  /** Subagent identifier (e.g. "build", "fast_edit") */
-  subagent?: string
-  toolCallId?: string
-  toolName?: string
-  success?: boolean
-  result?: unknown
-  /** Set on chat_id events */
-  chatId?: string
-  /** Set on title_updated events */
-  title?: string
-  /** Set on error events */
-  error?: string
-  /** Set on content/reasoning events */
-  content?: string
-  /** Set on reasoning events */
-  phase?: string
-  /** UI metadata from copilot (title, icon, phaseLabel) */
-  ui?: Record<string, unknown>
-  /** Set on resource_added events */
-  resource?: { type: string; id: string; title: string }
-}
+import type { AsyncCompletionSignal } from '@/lib/copilot/async-runs/lifecycle'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { StreamEvent } from '@/lib/copilot/request/session'
+import type { TraceCollector } from '@/lib/copilot/request/trace'
+import type { ToolExecutionContext, ToolExecutionResult } from '@/lib/copilot/tool-executor/types'
 
-export type ToolCallStatus =
-  | 'pending'
-  | 'executing'
-  | 'success'
-  | 'error'
-  | 'skipped'
-  | 'rejected'
-  | 'cancelled'
-
-const TERMINAL_TOOL_STATUSES: ReadonlySet<ToolCallStatus> = new Set([
-  'success',
-  'error',
-  'cancelled',
-  'skipped',
-  'rejected',
-])
+export type { StreamEvent }
+
+export type LocalToolCallStatus = 'pending' | 'executing'
+export type ToolCallStatus = LocalToolCallStatus | MothershipStreamV1ToolOutcome
+
+const TERMINAL_TOOL_STATUSES: ReadonlySet<ToolCallStatus> = new Set<MothershipStreamV1ToolOutcome>(
+  Object.values(MothershipStreamV1ToolOutcome)
+)
 
 export function isTerminalToolCallStatus(status?: string): boolean {
   return TERMINAL_TOOL_STATUSES.has(status as ToolCallStatus)
@@ -75,21 +21,33 @@ export interface ToolCallState {
   id: string
   name: string
   status: ToolCallStatus
+  displayTitle?: string
+  phaseLabel?: string
   params?: Record<string, unknown>
-  result?: ToolCallResult
+  result?: ToolCallStateResult
   error?: string
   startTime?: number
   endTime?: number
 }
 
-export interface ToolCallResult<T = unknown> {
+export type ToolCallResult<T = unknown> = ToolExecutionResult & {
+  output?: T
+}
+
+export interface ToolCallStateResult<T = unknown> {
   success: boolean
   output?: T
-  error?: string
-  resources?: MothershipResource[]
 }
 
-export type ContentBlockType = 'text' | 'thinking' | 'tool_call' | 'subagent_text' | 'subagent'
+export const ContentBlockType = {
+  text: 'text',
+  thinking: 'thinking',
+  tool_call: 'tool_call',
+  subagent_text: 'subagent_text',
+  subagent_thinking: 'subagent_thinking',
+  subagent: 'subagent',
+} as const
+export type ContentBlockType = (typeof ContentBlockType)[keyof typeof ContentBlockType]
 
 export interface ContentBlock {
   type: ContentBlockType
@@ -108,17 +66,20 @@ export interface StreamingContext {
   accumulatedContent: string
   contentBlocks: ContentBlock[]
   toolCalls: Map<string, ToolCallState>
-  pendingToolPromises: Map<
-    string,
-    Promise<{ status: string; message?: string; data?: Record<string, unknown> }>
-  >
+  pendingToolPromises: Map<string, Promise<AsyncCompletionSignal>>
   awaitingAsyncContinuation?: {
     checkpointId: string
     executionId?: string
     runId?: string
     pendingToolCallIds: string[]
+    frames?: Array<{
+      parentToolCallId: string
+      parentToolName: string
+      pendingToolIds: string[]
+    }>
   }
   currentThinkingBlock: ContentBlock | null
+  currentSubagentThinkingBlock: ContentBlock | null
   isInThinkingBlock: boolean
   subAgentParentToolCallId?: string
   subAgentParentStack: string[]
@@ -130,6 +91,15 @@ export interface StreamingContext {
   errors: string[]
   usage?: { prompt: number; completion: number }
   cost?: { input: number; output: number; total: number }
+  activeFileIntent?: {
+    toolCallId: string
+    operation: string
+    target: { kind: string; fileId?: string; fileName?: string }
+    title?: string
+    contentType?: string
+    edit?: Record<string, unknown>
+  } | null
+  trace: TraceCollector
 }
 
 export interface FileAttachment {
@@ -160,18 +130,10 @@ export interface OrchestratorRequest {
 export interface OrchestratorOptions {
   autoExecuteTools?: boolean
   timeout?: number
-  onEvent?: (event: SSEEvent) => void | Promise<void>
+  onEvent?: (event: StreamEvent) => void | Promise<void>
   onComplete?: (result: OrchestratorResult) => void | Promise<void>
   onError?: (error: Error) => void | Promise<void>
   abortSignal?: AbortSignal
-  /** Fires only on explicit user stop, never on passive transport disconnect. */
-  userStopSignal?: AbortSignal
-  /**
-   * Fires when the SSE client disconnects (tab close, navigation, etc.).
-   * Used to short-circuit `waitForToolCompletion` for client-executable tools
-   * so the orchestrator doesn't block for the full 60-min timeout.
-   */
-  clientDisconnectedSignal?: AbortSignal
   interactive?: boolean
 }
 
@@ -198,18 +160,6 @@ export interface ToolCallSummary {
   durationMs?: number
 }
 
-export interface ExecutionContext {
-  userId: string
-  workflowId: string
-  workspaceId?: string
-  chatId?: string
+export interface ExecutionContext extends ToolExecutionContext {
   messageId?: string
-  executionId?: string
-  runId?: string
-  abortSignal?: AbortSignal
-  /** Fires only on explicit user stop, never on passive transport disconnect. */
-  userStopSignal?: AbortSignal
-  userTimezone?: string
-  userPermission?: string
-  decryptedEnvVars?: Record<string, string>
 }
diff --git a/apps/sim/lib/copilot/resource-extraction.test.ts b/apps/sim/lib/copilot/resources/extraction.test.ts
similarity index 75%
rename from apps/sim/lib/copilot/resource-extraction.test.ts
rename to apps/sim/lib/copilot/resources/extraction.test.ts
index bb1b1677098..7f2ac6ed33e 100644
--- a/apps/sim/lib/copilot/resource-extraction.test.ts
+++ b/apps/sim/lib/copilot/resources/extraction.test.ts
@@ -2,9 +2,35 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { extractResourcesFromToolResult } from './resource-extraction'
+import { extractResourcesFromToolResult } from './extraction'
 
 describe('extractResourcesFromToolResult', () => {
+  it('extracts file resources from create_file results', () => {
+    const resources = extractResourcesFromToolResult(
+      'create_file',
+      {
+        fileName: 'notes.md',
+      },
+      {
+        success: true,
+        message: 'File "notes.md" created successfully',
+        data: {
+          id: 'file_123',
+          name: 'notes.md',
+          contentType: 'text/markdown',
+        },
+      }
+    )
+
+    expect(resources).toEqual([
+      {
+        type: 'file',
+        id: 'file_123',
+        title: 'notes.md',
+      },
+    ])
+  })
+
   it('uses the knowledge base id for knowledge_base tag mutations', () => {
     const resources = extractResourcesFromToolResult(
       'knowledge_base',
diff --git a/apps/sim/lib/copilot/resource-extraction.ts b/apps/sim/lib/copilot/resources/extraction.ts
similarity index 64%
rename from apps/sim/lib/copilot/resource-extraction.ts
rename to apps/sim/lib/copilot/resources/extraction.ts
index 9887ea5ded3..29ca644a21a 100644
--- a/apps/sim/lib/copilot/resource-extraction.ts
+++ b/apps/sim/lib/copilot/resources/extraction.ts
@@ -1,96 +1,40 @@
-import type { MothershipResource, MothershipResourceType } from '@/lib/copilot/resource-types'
+import {
+  CreateFile,
+  CreateWorkflow,
+  DeleteWorkflow,
+  DownloadToWorkspaceFile,
+  EditWorkflow,
+  FunctionExecute,
+  GenerateImage,
+  GenerateVisualization,
+  GetWorkflowLogs,
+  Knowledge,
+  KnowledgeBase,
+  UserTable,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
+import type { MothershipResource, MothershipResourceType } from './types'
 
 type ChatResource = MothershipResource
 type ResourceType = MothershipResourceType
 
-/**
- * Defines how each tool's result is surfaced in the resource panel:
- * - `dedicated` — opens its own resource tab (table, file, workflow, knowledgebase)
- * - `deferred`  — may open a dedicated tab; falls back to the Results tab if no resource is produced
- * - `excluded`  — hidden from the resource panel (internal tools, management, subagent wrappers)
- *
- * Any tool not listed here appears in the generic Results tab by default.
- */
-const TOOL_PANEL_BEHAVIOR: Record<string, 'dedicated' | 'deferred' | 'excluded'> = {
-  // Dedicated resource tab openers
-  user_table: 'dedicated',
-  workspace_file: 'dedicated',
-  download_to_workspace_file: 'dedicated',
-  create_workflow: 'dedicated',
-  edit_workflow: 'dedicated',
-  knowledge_base: 'dedicated',
-  knowledge: 'dedicated',
-  generate_visualization: 'dedicated',
-  generate_image: 'dedicated',
-  // Deferred: may produce a dedicated resource; falls back to Results tab otherwise
-  function_execute: 'deferred',
-  // Excluded: saves files without opening a resource tab
-  materialize_file: 'excluded',
-  // Excluded: internal / invisible
-  user_memory: 'excluded',
-  context_write: 'excluded',
-  context_compaction: 'excluded',
-  // Excluded: workflow and folder management
-  rename_workflow: 'excluded',
-  move_workflow: 'excluded',
-  delete_workflow: 'excluded',
-  create_folder: 'excluded',
-  delete_folder: 'excluded',
-  move_folder: 'excluded',
-  list_folders: 'excluded',
-  list_user_workspaces: 'excluded',
-  open_resource: 'excluded',
-  // Excluded: settings and credential management
-  set_environment_variables: 'excluded',
-  set_global_workflow_variables: 'excluded',
-  manage_mcp_tool: 'excluded',
-  manage_skill: 'excluded',
-  manage_credential: 'excluded',
-  manage_custom_tool: 'excluded',
-  oauth_get_auth_link: 'excluded',
-  oauth_request_access: 'excluded',
-  update_workspace_mcp_server: 'excluded',
-  delete_workspace_mcp_server: 'excluded',
-  create_workspace_mcp_server: 'excluded',
-  list_workspace_mcp_servers: 'excluded',
-  // Excluded: subagent wrappers — inner tools fire as individual events
-  build: 'excluded',
-  run: 'excluded',
-  deploy: 'excluded',
-  auth: 'excluded',
-  table: 'excluded',
-  job: 'excluded',
-  agent: 'excluded',
-  custom_tool: 'excluded',
-  research: 'excluded',
-  plan: 'excluded',
-  debug: 'excluded',
-  edit: 'excluded',
-  fast_edit: 'excluded',
-}
-
-/**
- * Returns true for resources that are client-only and must never be persisted to the server.
- * This covers the generic Results tab and the in-flight streaming-file preview.
- */
-export function isEphemeralResource(resource: { id: string; type: string }): boolean {
-  return resource.type === 'generic' || resource.id === 'streaming-file'
-}
+const RESOURCE_TOOL_NAMES: Set<string> = new Set([
+  UserTable.id,
+  CreateFile.id,
+  WorkspaceFile.id,
+  DownloadToWorkspaceFile.id,
+  CreateWorkflow.id,
+  EditWorkflow.id,
+  FunctionExecute.id,
+  KnowledgeBase.id,
+  Knowledge.id,
+  GenerateVisualization.id,
+  GenerateImage.id,
+  GetWorkflowLogs.id,
+])
 
-/** Returns true for tools that open a dedicated resource tab or may fall back to the Results tab. */
 export function isResourceToolName(toolName: string): boolean {
-  const b = TOOL_PANEL_BEHAVIOR[toolName]
-  return b === 'dedicated' || b === 'deferred'
-}
-
-/** Returns true if the tool's result should appear in the Results tab at call time. */
-export function shouldOpenGenericResource(toolName: string): boolean {
-  return !(toolName in TOOL_PANEL_BEHAVIOR)
-}
-
-/** Returns true for tools that may fall back to the Results tab at completion time. */
-export function isDeferredResourceTool(toolName: string): boolean {
-  return TOOL_PANEL_BEHAVIOR[toolName] === 'deferred'
+  return RESOURCE_TOOL_NAMES.has(toolName)
 }
 
 function asRecord(value: unknown): Record<string, unknown> {
@@ -102,6 +46,12 @@ function getOperation(params: Record<string, unknown> | undefined): string | und
   return (args.operation ?? params?.operation) as string | undefined
 }
 
+function getWorkspaceFileTarget(
+  params: Record<string, unknown> | undefined
+): Record<string, unknown> {
+  return asRecord(params?.target)
+}
+
 const READ_ONLY_TABLE_OPS = new Set(['get', 'get_schema', 'get_row', 'query_rows'])
 const READ_ONLY_KB_OPS = new Set(['get', 'query', 'list_tags', 'get_tag_usage'])
 const READ_ONLY_KNOWLEDGE_ACTIONS = new Set(['listed', 'queried'])
@@ -122,7 +72,7 @@ export function extractResourcesFromToolResult(
   const data = asRecord(result.data)
 
   switch (toolName) {
-    case 'user_table': {
+    case UserTable.id: {
       if (READ_ONLY_TABLE_OPS.has(getOperation(params) ?? '')) return []
 
       if (result.tableId) {
@@ -158,7 +108,8 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'workspace_file': {
+    case CreateFile.id:
+    case WorkspaceFile.id: {
       const file = asRecord(data.file)
       if (file.id) {
         return [{ type: 'file', id: file.id as string, title: (file.name as string) || 'File' }]
@@ -171,7 +122,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'function_execute': {
+    case FunctionExecute.id: {
       if (result.tableId) {
         return [
           {
@@ -193,9 +144,9 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'download_to_workspace_file':
-    case 'generate_visualization':
-    case 'generate_image': {
+    case DownloadToWorkspaceFile.id:
+    case GenerateVisualization.id:
+    case GenerateImage.id: {
       if (result.fileId) {
         return [
           {
@@ -208,8 +159,8 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'create_workflow':
-    case 'edit_workflow': {
+    case CreateWorkflow.id:
+    case EditWorkflow.id: {
       const workflowId =
         (result.workflowId as string) ??
         (data.workflowId as string) ??
@@ -225,7 +176,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'knowledge_base': {
+    case KnowledgeBase.id: {
       if (READ_ONLY_KB_OPS.has(getOperation(params) ?? '')) return []
 
       const args = asRecord(params?.args)
@@ -243,7 +194,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case 'knowledge': {
+    case Knowledge.id: {
       const action = data.action as string | undefined
       if (READ_ONLY_KNOWLEDGE_ACTIONS.has(action ?? '')) return []
 
@@ -263,16 +214,29 @@ export function extractResourcesFromToolResult(
       return resources
     }
 
+    case GetWorkflowLogs.id: {
+      const entries = Array.isArray(output) ? output : Array.isArray(result.data) ? result.data : []
+      const resources: ChatResource[] = []
+      for (const entry of entries) {
+        const rec = asRecord(entry)
+        const logId = rec.id as string | undefined
+        if (logId) {
+          resources.push({ type: 'log', id: logId, title: 'Log' })
+        }
+      }
+      return resources
+    }
+
     default:
       return []
   }
 }
 
 const DELETE_CAPABLE_TOOL_RESOURCE_TYPE: Record<string, ResourceType> = {
-  delete_workflow: 'workflow',
-  workspace_file: 'file',
-  user_table: 'table',
-  knowledge_base: 'knowledgebase',
+  [DeleteWorkflow.id]: 'workflow',
+  [WorkspaceFile.id]: 'file',
+  [UserTable.id]: 'table',
+  [KnowledgeBase.id]: 'knowledgebase',
 }
 
 export function hasDeleteCapability(toolName: string): boolean {
@@ -298,7 +262,7 @@ export function extractDeletedResourcesFromToolResult(
   const operation = (args.operation ?? params?.operation) as string | undefined
 
   switch (toolName) {
-    case 'delete_workflow': {
+    case DeleteWorkflow.id: {
       const workflowId = (result.workflowId as string) ?? (params?.workflowId as string)
       if (workflowId && result.deleted) {
         return [
@@ -308,16 +272,17 @@ export function extractDeletedResourcesFromToolResult(
       return []
     }
 
-    case 'workspace_file': {
+    case WorkspaceFile.id: {
       if (operation !== 'delete') return []
-      const fileId = (data.id as string) ?? (args.fileId as string)
+      const target = getWorkspaceFileTarget(params)
+      const fileId = (data.id as string) ?? (target.fileId as string) ?? (args.fileId as string)
       if (fileId) {
         return [{ type: resourceType, id: fileId, title: (data.name as string) || 'File' }]
       }
       return []
     }
 
-    case 'user_table': {
+    case UserTable.id: {
       if (operation !== 'delete') return []
       const tableId = (args.tableId as string) ?? (params?.tableId as string)
       if (tableId) {
@@ -326,7 +291,7 @@ export function extractDeletedResourcesFromToolResult(
       return []
     }
 
-    case 'knowledge_base': {
+    case KnowledgeBase.id: {
       if (operation !== 'delete') return []
       const kbId = (data.id as string) ?? (args.knowledgeBaseId as string)
       if (kbId) {
diff --git a/apps/sim/lib/copilot/resources.ts b/apps/sim/lib/copilot/resources/persistence.ts
similarity index 80%
rename from apps/sim/lib/copilot/resources.ts
rename to apps/sim/lib/copilot/resources/persistence.ts
index 4a674c83119..9ffc724c1ab 100644
--- a/apps/sim/lib/copilot/resources.ts
+++ b/apps/sim/lib/copilot/resources/persistence.ts
@@ -2,32 +2,32 @@ import { db } from '@sim/db'
 import { copilotChats } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq, sql } from 'drizzle-orm'
-import { isEphemeralResource } from '@/lib/copilot/resource-extraction'
-import type { MothershipResource } from '@/lib/copilot/resource-types'
+import type { MothershipResource } from './types'
 
 export {
   extractDeletedResourcesFromToolResult,
   extractResourcesFromToolResult,
   hasDeleteCapability,
-  isEphemeralResource,
   isResourceToolName,
-} from '@/lib/copilot/resource-extraction'
+} from './extraction'
 export type {
   MothershipResource as ChatResource,
   MothershipResourceType as ResourceType,
-} from '@/lib/copilot/resource-types'
+} from './types'
 
 const logger = createLogger('CopilotResources')
 
+type ChatResource = MothershipResource
+
 /**
  * Appends resources to a chat's JSONB resources column, deduplicating by type+id.
  * Updates the title of existing resources if the new title is more specific.
  */
 export async function persistChatResources(
   chatId: string,
-  newResources: MothershipResource[]
+  newResources: ChatResource[]
 ): Promise<void> {
-  const toMerge = newResources.filter((r) => !isEphemeralResource(r))
+  const toMerge = newResources.filter((r) => r.id !== 'streaming-file')
   if (toMerge.length === 0) return
 
   try {
@@ -39,9 +39,9 @@ export async function persistChatResources(
 
     if (!chat) return
 
-    const existing = Array.isArray(chat.resources) ? (chat.resources as MothershipResource[]) : []
-    const map = new Map<string, MothershipResource>()
-    const GENERIC = new Set(['Table', 'File', 'Workflow', 'Knowledge Base', 'Folder'])
+    const existing = Array.isArray(chat.resources) ? (chat.resources as ChatResource[]) : []
+    const map = new Map<string, ChatResource>()
+    const GENERIC = new Set(['Table', 'File', 'Workflow', 'Knowledge Base', 'Folder', 'Log'])
 
     for (const r of existing) {
       map.set(`${r.type}:${r.id}`, r)
@@ -72,10 +72,7 @@ export async function persistChatResources(
 /**
  * Removes resources from a chat's JSONB resources column by type+id.
  */
-export async function removeChatResources(
-  chatId: string,
-  toRemove: MothershipResource[]
-): Promise<void> {
+export async function removeChatResources(chatId: string, toRemove: ChatResource[]): Promise<void> {
   if (toRemove.length === 0) return
 
   try {
@@ -87,7 +84,7 @@ export async function removeChatResources(
 
     if (!chat) return
 
-    const existing = Array.isArray(chat.resources) ? (chat.resources as MothershipResource[]) : []
+    const existing = Array.isArray(chat.resources) ? (chat.resources as ChatResource[]) : []
     const removeKeys = new Set(toRemove.map((r) => `${r.type}:${r.id}`))
     const filtered = existing.filter((r) => !removeKeys.has(`${r.type}:${r.id}`))
 
diff --git a/apps/sim/lib/copilot/resources/types.ts b/apps/sim/lib/copilot/resources/types.ts
new file mode 100644
index 00000000000..a50ce7dc0b4
--- /dev/null
+++ b/apps/sim/lib/copilot/resources/types.ts
@@ -0,0 +1,30 @@
+export const MothershipResourceType = {
+  table: 'table',
+  file: 'file',
+  workflow: 'workflow',
+  knowledgebase: 'knowledgebase',
+  folder: 'folder',
+  task: 'task',
+  log: 'log',
+  generic: 'generic',
+} as const
+export type MothershipResourceType =
+  (typeof MothershipResourceType)[keyof typeof MothershipResourceType]
+
+export interface MothershipResource {
+  type: MothershipResourceType
+  id: string
+  title: string
+}
+
+export function isEphemeralResource(resource: MothershipResource): boolean {
+  return resource.type === 'generic' || resource.id === 'streaming-file'
+}
+
+export const VFS_DIR_TO_RESOURCE: Record<string, MothershipResourceType> = {
+  tables: 'table',
+  files: 'file',
+  workflows: 'workflow',
+  knowledgebases: 'knowledgebase',
+  folders: 'folder',
+} as const
diff --git a/apps/sim/lib/copilot/task-events.ts b/apps/sim/lib/copilot/tasks.ts
similarity index 95%
rename from apps/sim/lib/copilot/task-events.ts
rename to apps/sim/lib/copilot/tasks.ts
index 50653809bf4..5828a711cb4 100644
--- a/apps/sim/lib/copilot/task-events.ts
+++ b/apps/sim/lib/copilot/tasks.ts
@@ -9,7 +9,7 @@
 
 import { createPubSubChannel } from '@/lib/events/pubsub'
 
-export interface TaskStatusEvent {
+interface TaskStatusEvent {
   workspaceId: string
   chatId: string
   type: 'started' | 'completed' | 'created' | 'deleted' | 'renamed'
diff --git a/apps/sim/lib/copilot/tool-executor/executor.test.ts b/apps/sim/lib/copilot/tool-executor/executor.test.ts
new file mode 100644
index 00000000000..4ae97dd45c7
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/executor.test.ts
@@ -0,0 +1,61 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { isKnownTool, isSimExecuted } = vi.hoisted(() => ({
+  isKnownTool: vi.fn(),
+  isSimExecuted: vi.fn(),
+}))
+
+const { executeAppTool } = vi.hoisted(() => ({
+  executeAppTool: vi.fn(),
+}))
+
+vi.mock('./router', () => ({
+  isKnownTool,
+  isSimExecuted,
+}))
+
+vi.mock('@/tools', () => ({
+  executeTool: executeAppTool,
+}))
+
+import { executeTool } from './executor'
+
+describe('copilot tool executor fallback', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('falls back to app tool executor for dynamic sim tools', async () => {
+    isKnownTool.mockReturnValue(false)
+    isSimExecuted.mockReturnValue(false)
+    executeAppTool.mockResolvedValue({ success: true, output: { emails: [] } })
+
+    const result = await executeTool(
+      'gmail_read',
+      { maxResults: 10, credentialId: 'cred-123' },
+      { userId: 'user-1', workflowId: 'workflow-1', workspaceId: 'ws-1', chatId: 'chat-1' }
+    )
+
+    expect(executeAppTool).toHaveBeenCalledWith(
+      'gmail_read',
+      expect.objectContaining({
+        maxResults: 10,
+        credentialId: 'cred-123',
+        credential: 'cred-123',
+        _context: expect.objectContaining({
+          userId: 'user-1',
+          workflowId: 'workflow-1',
+          workspaceId: 'ws-1',
+          chatId: 'chat-1',
+          enforceCredentialAccess: true,
+        }),
+      }),
+      false
+    )
+    expect(result).toEqual({ success: true, output: { emails: [] } })
+  })
+})
diff --git a/apps/sim/lib/copilot/tool-executor/executor.ts b/apps/sim/lib/copilot/tool-executor/executor.ts
new file mode 100644
index 00000000000..f35a1116ee3
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/executor.ts
@@ -0,0 +1,123 @@
+import { createLogger } from '@sim/logger'
+import { executeTool as executeAppTool } from '@/tools'
+import { isKnownTool, isSimExecuted } from './router'
+import type {
+  ToolCallDescriptor,
+  ToolExecutionContext,
+  ToolExecutionResult,
+  ToolHandler,
+} from './types'
+
+const logger = createLogger('ToolExecutor')
+
+const handlerRegistry = new Map<string, ToolHandler>()
+
+export function registerHandler(toolId: string, handler: ToolHandler): void {
+  handlerRegistry.set(toolId, handler)
+}
+
+export function registerHandlers(entries: Record<string, ToolHandler>): void {
+  for (const [toolId, handler] of Object.entries(entries)) {
+    handlerRegistry.set(toolId, handler)
+  }
+}
+
+export function getRegisteredToolIds(): string[] {
+  return Array.from(handlerRegistry.keys())
+}
+
+export function hasHandler(toolId: string): boolean {
+  return handlerRegistry.has(toolId)
+}
+
+export async function executeTool(
+  toolId: string,
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+): Promise<ToolExecutionResult> {
+  const canUseRegisteredHandler = isKnownTool(toolId) && isSimExecuted(toolId)
+  if (!canUseRegisteredHandler) {
+    const appParams = buildAppToolParams(params, context)
+    return executeAppTool(toolId, appParams, false)
+  }
+
+  if (context.abortSignal?.aborted) {
+    logger.warn('Tool execution skipped: abort signal already set', {
+      toolId,
+      abortReason: context.abortSignal.reason ?? 'unknown',
+    })
+    return { success: false, error: 'Execution aborted: abort signal was set before tool started' }
+  }
+
+  const handler = handlerRegistry.get(toolId)
+  if (!handler) {
+    logger.warn('No handler registered for tool', { toolId })
+    return { success: false, error: `No handler for tool: ${toolId}` }
+  }
+
+  try {
+    return await handler(params, context)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    logger.error('Tool execution failed', {
+      toolId,
+      error: message,
+      abortSignalAborted: context.abortSignal?.aborted ?? false,
+    })
+    return { success: false, error: message }
+  }
+}
+
+export async function executeToolBatch(
+  toolCalls: ToolCallDescriptor[],
+  context: ToolExecutionContext
+): Promise<Map<string, ToolExecutionResult>> {
+  const results = new Map<string, ToolExecutionResult>()
+
+  const executions = toolCalls.map(async ({ toolCallId, toolId, params }) => {
+    const result = await executeTool(toolId, params, context)
+    results.set(toolCallId, result)
+  })
+
+  await Promise.allSettled(executions)
+
+  for (const { toolCallId } of toolCalls) {
+    if (!results.has(toolCallId)) {
+      results.set(toolCallId, {
+        success: false,
+        error: 'Tool execution did not produce a result',
+      })
+    }
+  }
+
+  return results
+}
+
+function buildAppToolParams(
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+): Record<string, unknown> {
+  const result = { ...params }
+
+  if (result.credentialId && !result.credential && !result.oauthCredential) {
+    result.credential = result.credentialId
+  }
+
+  result._context = {
+    ...(typeof result._context === 'object' && result._context !== null
+      ? (result._context as object)
+      : {}),
+    userId: context.userId,
+    workflowId: context.workflowId,
+    workspaceId: context.workspaceId,
+    chatId: context.chatId,
+    executionId: context.executionId,
+    runId: context.runId,
+    copilotToolExecution: context.copilotToolExecution,
+    requestMode: context.requestMode,
+    currentAgentId: context.currentAgentId,
+    enforceCredentialAccess: true,
+  }
+
+  return result
+}
diff --git a/apps/sim/lib/copilot/tool-executor/index.ts b/apps/sim/lib/copilot/tool-executor/index.ts
new file mode 100644
index 00000000000..8bec66e812f
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/index.ts
@@ -0,0 +1,25 @@
+export {
+  executeTool,
+  executeToolBatch,
+  getRegisteredToolIds,
+  hasHandler,
+  registerHandler,
+  registerHandlers,
+} from './executor'
+export { ensureHandlersRegistered } from './register-handlers'
+export {
+  getToolEntry,
+  isGoExecuted,
+  isKnownTool,
+  isSimExecuted,
+  type PartitionedBatch,
+  partitionToolBatch,
+  routeToolCall,
+  type ToolRoute,
+} from './router'
+export type {
+  ToolCallDescriptor,
+  ToolExecutionContext,
+  ToolExecutionResult,
+  ToolHandler,
+} from './types'
diff --git a/apps/sim/lib/copilot/tool-executor/register-handlers.ts b/apps/sim/lib/copilot/tool-executor/register-handlers.ts
new file mode 100644
index 00000000000..95433dabde2
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/register-handlers.ts
@@ -0,0 +1,200 @@
+import { createLogger } from '@sim/logger'
+import {
+  CheckDeploymentStatus,
+  CompleteJob,
+  CreateFolder,
+  CreateJob,
+  CreateWorkflow,
+  CreateWorkspaceMcpServer,
+  DeleteFolder,
+  DeleteWorkflow,
+  DeleteWorkspaceMcpServer,
+  DeployApi,
+  DeployChat,
+  DeployMcp,
+  FunctionExecute,
+  GenerateApiKey,
+  GetBlockOutputs,
+  GetBlockUpstreamReferences,
+  GetDeployedWorkflowState,
+  GetDeploymentVersion,
+  GetPlatformActions,
+  GetWorkflowData,
+  Glob as GlobTool,
+  Grep as GrepTool,
+  ListFolders,
+  ListUserWorkspaces,
+  ListWorkspaceMcpServers,
+  ManageCredential,
+  ManageCustomTool,
+  ManageJob,
+  ManageMcpTool,
+  ManageSkill,
+  MaterializeFile,
+  MoveFolder,
+  MoveWorkflow,
+  OauthGetAuthLink,
+  OauthRequestAccess,
+  OpenResource,
+  Read as ReadTool,
+  Redeploy,
+  RenameWorkflow,
+  RestoreResource,
+  RevertToVersion,
+  RunBlock,
+  RunFromBlock,
+  RunWorkflow,
+  RunWorkflowUntilBlock,
+  SetBlockEnabled,
+  SetGlobalWorkflowVariables,
+  UpdateJobHistory,
+  UpdateWorkspaceMcpServer,
+} from '@/lib/copilot/generated/tool-catalog-v1'
+import { createServerToolHandler } from '@/lib/copilot/tools/registry/server-tool-adapter'
+import { getRegisteredServerToolNames } from '@/lib/copilot/tools/server/router'
+import {
+  executeDeployApi,
+  executeDeployChat,
+  executeDeployMcp,
+  executeRedeploy,
+} from '../tools/handlers/deployment/deploy'
+import {
+  executeCheckDeploymentStatus,
+  executeCreateWorkspaceMcpServer,
+  executeDeleteWorkspaceMcpServer,
+  executeGetDeploymentVersion,
+  executeListWorkspaceMcpServers,
+  executeRevertToVersion,
+  executeUpdateWorkspaceMcpServer,
+} from '../tools/handlers/deployment/manage'
+import { executeFunctionExecute } from '../tools/handlers/function-execute'
+import {
+  executeCompleteJob,
+  executeCreateJob,
+  executeManageJob,
+  executeUpdateJobHistory,
+} from '../tools/handlers/jobs'
+import { executeManageCredential } from '../tools/handlers/management/manage-credential'
+import { executeManageCustomTool } from '../tools/handlers/management/manage-custom-tool'
+import { executeManageMcpTool } from '../tools/handlers/management/manage-mcp-tool'
+import { executeManageSkill } from '../tools/handlers/management/manage-skill'
+import { executeMaterializeFile } from '../tools/handlers/materialize-file'
+import { executeOAuthGetAuthLink, executeOAuthRequestAccess } from '../tools/handlers/oauth'
+import { executeGetPlatformActions } from '../tools/handlers/platform'
+import { executeOpenResource } from '../tools/handlers/resources'
+import { executeRestoreResource } from '../tools/handlers/restore-resource'
+import { executeVfsGlob, executeVfsGrep, executeVfsRead } from '../tools/handlers/vfs'
+import {
+  executeCreateFolder,
+  executeCreateWorkflow,
+  executeDeleteFolder,
+  executeDeleteWorkflow,
+  executeGenerateApiKey,
+  executeMoveFolder,
+  executeMoveWorkflow,
+  executeRenameWorkflow,
+  executeRunBlock,
+  executeRunFromBlock,
+  executeRunWorkflow,
+  executeRunWorkflowUntilBlock,
+  executeSetBlockEnabled,
+  executeSetGlobalWorkflowVariables,
+} from '../tools/handlers/workflow/mutations'
+import {
+  executeGetBlockOutputs,
+  executeGetBlockUpstreamReferences,
+  executeGetDeployedWorkflowState,
+  executeGetWorkflowData,
+  executeListFolders,
+  executeListUserWorkspaces,
+} from '../tools/handlers/workflow/queries'
+import { registerHandlers } from './executor'
+import type { ToolHandler } from './types'
+
+const logger = createLogger('ToolHandlerRegistration')
+
+let registered = false
+
+export function ensureHandlersRegistered(): void {
+  if (registered) return
+  registered = true
+  registerHandlers(buildHandlerMap())
+  logger.info('Tool handlers registered')
+}
+
+// Bridge: handler implementations accept specific param types (e.g. CreateWorkflowParams)
+// while ToolHandler accepts Record<string, unknown>. The params are cast internally by
+// each implementation. ExecutionContext extends ToolExecutionContext so context is compatible.
+function h(fn: (params: any, context: any) => Promise<any>): ToolHandler {
+  return fn as ToolHandler
+}
+
+function buildHandlerMap(): Record<string, ToolHandler> {
+  return {
+    [ListUserWorkspaces.id]: h((_p, c) => executeListUserWorkspaces(c)),
+    [ListFolders.id]: h(executeListFolders),
+    [GetWorkflowData.id]: h(executeGetWorkflowData),
+    [GetBlockOutputs.id]: h(executeGetBlockOutputs),
+    [GetBlockUpstreamReferences.id]: h(executeGetBlockUpstreamReferences),
+    [GetDeployedWorkflowState.id]: h(executeGetDeployedWorkflowState),
+
+    [CreateWorkflow.id]: h(executeCreateWorkflow),
+    [CreateFolder.id]: h(executeCreateFolder),
+    [DeleteWorkflow.id]: h(executeDeleteWorkflow),
+    [DeleteFolder.id]: h(executeDeleteFolder),
+    [RenameWorkflow.id]: h(executeRenameWorkflow),
+    [MoveWorkflow.id]: h(executeMoveWorkflow),
+    [MoveFolder.id]: h(executeMoveFolder),
+    [RunWorkflow.id]: h(executeRunWorkflow),
+    [RunWorkflowUntilBlock.id]: h(executeRunWorkflowUntilBlock),
+    [RunFromBlock.id]: h(executeRunFromBlock),
+    [RunBlock.id]: h(executeRunBlock),
+    [SetBlockEnabled.id]: h(executeSetBlockEnabled),
+    [GenerateApiKey.id]: h(executeGenerateApiKey),
+    [SetGlobalWorkflowVariables.id]: h(executeSetGlobalWorkflowVariables),
+
+    [DeployApi.id]: h(executeDeployApi),
+    [DeployChat.id]: h(executeDeployChat),
+    [DeployMcp.id]: h(executeDeployMcp),
+    [Redeploy.id]: h(executeRedeploy),
+    [CheckDeploymentStatus.id]: h(executeCheckDeploymentStatus),
+    [ListWorkspaceMcpServers.id]: h(executeListWorkspaceMcpServers),
+    [CreateWorkspaceMcpServer.id]: h(executeCreateWorkspaceMcpServer),
+    [UpdateWorkspaceMcpServer.id]: h(executeUpdateWorkspaceMcpServer),
+    [DeleteWorkspaceMcpServer.id]: h(executeDeleteWorkspaceMcpServer),
+    [GetDeploymentVersion.id]: h(executeGetDeploymentVersion),
+    [RevertToVersion.id]: h(executeRevertToVersion),
+
+    [CreateJob.id]: h(executeCreateJob),
+    [ManageJob.id]: h(executeManageJob),
+    [CompleteJob.id]: h(executeCompleteJob),
+    [UpdateJobHistory.id]: h(executeUpdateJobHistory),
+
+    [GrepTool.id]: h(executeVfsGrep),
+    [GlobTool.id]: h(executeVfsGlob),
+    [ReadTool.id]: h(executeVfsRead),
+
+    [ManageCustomTool.id]: h(executeManageCustomTool),
+    [ManageMcpTool.id]: h(executeManageMcpTool),
+    [ManageSkill.id]: h(executeManageSkill),
+    [ManageCredential.id]: h(executeManageCredential),
+    [OauthGetAuthLink.id]: h(executeOAuthGetAuthLink),
+    [OauthRequestAccess.id]: h(executeOAuthRequestAccess),
+    [OpenResource.id]: h(executeOpenResource),
+    [RestoreResource.id]: h(executeRestoreResource),
+    [GetPlatformActions.id]: h(executeGetPlatformActions),
+    [MaterializeFile.id]: h(executeMaterializeFile),
+    [FunctionExecute.id]: h(executeFunctionExecute),
+
+    ...buildServerToolHandlers(),
+  }
+}
+
+function buildServerToolHandlers(): Record<string, ToolHandler> {
+  const toolNames = getRegisteredServerToolNames()
+  const handlers: Record<string, ToolHandler> = {}
+  for (const toolId of toolNames) {
+    handlers[toolId] = createServerToolHandler(toolId)
+  }
+  return handlers
+}
diff --git a/apps/sim/lib/copilot/tool-executor/router.ts b/apps/sim/lib/copilot/tool-executor/router.ts
new file mode 100644
index 00000000000..18961524447
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/router.ts
@@ -0,0 +1,59 @@
+import { TOOL_CATALOG, type ToolCatalogEntry } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { ToolCallDescriptor } from './types'
+
+export type ToolRouteTarget = ToolCatalogEntry['route']
+
+export function isToolInCatalog(toolId: string): boolean {
+  return toolId in TOOL_CATALOG
+}
+
+export function getToolEntry(toolId: string): ToolCatalogEntry | undefined {
+  return TOOL_CATALOG[toolId]
+}
+
+export type ToolRoute = {
+  route: ToolRouteTarget
+  mode: ToolCatalogEntry['mode']
+  subagentId?: string
+}
+
+export function routeToolCall(toolId: string): ToolRoute | null {
+  const entry = getToolEntry(toolId)
+  if (!entry) return null
+  return { route: entry.route, mode: entry.mode, subagentId: entry.subagentId }
+}
+
+export function isSimExecuted(toolId: string): boolean {
+  return getToolEntry(toolId)?.route === 'sim'
+}
+
+export function isGoExecuted(toolId: string): boolean {
+  return getToolEntry(toolId)?.route === 'go'
+}
+
+export function isKnownTool(toolId: string): boolean {
+  return isToolInCatalog(toolId)
+}
+
+export interface PartitionedBatch {
+  sim: ToolCallDescriptor[]
+  go: ToolCallDescriptor[]
+  subagent: ToolCallDescriptor[]
+  client: ToolCallDescriptor[]
+  unknown: ToolCallDescriptor[]
+}
+
+export function partitionToolBatch(toolCalls: ToolCallDescriptor[]): PartitionedBatch {
+  const result: PartitionedBatch = { sim: [], go: [], subagent: [], client: [], unknown: [] }
+
+  for (const tc of toolCalls) {
+    const route = routeToolCall(tc.toolId)
+    if (!route) {
+      result.unknown.push(tc)
+      continue
+    }
+    result[route.route].push(tc)
+  }
+
+  return result
+}
diff --git a/apps/sim/lib/copilot/tool-executor/types.ts b/apps/sim/lib/copilot/tool-executor/types.ts
new file mode 100644
index 00000000000..9087f38f634
--- /dev/null
+++ b/apps/sim/lib/copilot/tool-executor/types.ts
@@ -0,0 +1,36 @@
+import type { MothershipResource } from '@/lib/copilot/resources/types'
+
+export interface ToolExecutionContext {
+  userId: string
+  workflowId: string
+  workspaceId?: string
+  chatId?: string
+  messageId?: string
+  executionId?: string
+  runId?: string
+  copilotToolExecution?: boolean
+  requestMode?: string
+  currentAgentId?: string
+  abortSignal?: AbortSignal
+  userTimezone?: string
+  userPermission?: string
+  decryptedEnvVars?: Record<string, string>
+}
+
+export interface ToolExecutionResult {
+  success: boolean
+  output?: unknown
+  error?: string
+  resources?: MothershipResource[]
+}
+
+export type ToolHandler = (
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+) => Promise<ToolExecutionResult>
+
+export interface ToolCallDescriptor {
+  toolCallId: string
+  toolId: string
+  params: Record<string, unknown>
+}
diff --git a/apps/sim/lib/copilot/tools/client/hidden-tools.ts b/apps/sim/lib/copilot/tools/client/hidden-tools.ts
new file mode 100644
index 00000000000..d50d73c1957
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/client/hidden-tools.ts
@@ -0,0 +1,9 @@
+const HIDDEN_TOOL_NAMES = new Set(['tool_search_tool_regex', 'load_agent_skill'])
+
+export function isToolHiddenInUi(toolName: string | undefined): boolean {
+  return !!toolName && HIDDEN_TOOL_NAMES.has(toolName)
+}
+
+export function getHiddenToolNames(): ReadonlySet<string> {
+  return HIDDEN_TOOL_NAMES
+}
diff --git a/apps/sim/lib/copilot/client-sse/run-tool-execution.test.ts b/apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
similarity index 51%
rename from apps/sim/lib/copilot/client-sse/run-tool-execution.test.ts
rename to apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
index 395dd25741e..1de7a8ccc1a 100644
--- a/apps/sim/lib/copilot/client-sse/run-tool-execution.test.ts
+++ b/apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
@@ -4,8 +4,20 @@
 
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { executeWorkflowWithFullLogging } = vi.hoisted(() => ({
+const {
+  clearExecutionPointer,
+  executeWorkflowWithFullLogging,
+  getWorkflowEntries,
+  loadExecutionPointer,
+  saveExecutionPointer,
+  setActiveWorkflow,
+} = vi.hoisted(() => ({
+  clearExecutionPointer: vi.fn(),
   executeWorkflowWithFullLogging: vi.fn(),
+  getWorkflowEntries: vi.fn(() => []),
+  loadExecutionPointer: vi.fn(),
+  saveExecutionPointer: vi.fn(),
+  setActiveWorkflow: vi.fn(),
 }))
 
 const setIsExecuting = vi.fn()
@@ -30,7 +42,7 @@ vi.mock('@/stores/workflows/registry/store', () => ({
   useWorkflowRegistry: {
     getState: () => ({
       activeWorkflowId: 'wf-1',
-      setActiveWorkflow: vi.fn(),
+      setActiveWorkflow,
     }),
   },
 }))
@@ -41,11 +53,18 @@ vi.mock('@/stores/terminal', () => ({
     executionEnded: vi.fn(),
     persist: vi.fn(),
   },
-  saveExecutionPointer: vi.fn(),
-  clearExecutionPointer: vi.fn(),
+  clearExecutionPointer,
+  loadExecutionPointer,
+  saveExecutionPointer,
+  useTerminalConsoleStore: {
+    getState: () => ({
+      getWorkflowEntries,
+    }),
+  },
 }))
 
 import {
+  bindRunToolToExecution,
   cancelRunToolExecution,
   executeRunToolOnClient,
   reportManualRunToolStop,
@@ -54,6 +73,9 @@ import {
 describe('run tool execution cancellation', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    getWorkflowEntries.mockReturnValue([])
+    loadExecutionPointer.mockResolvedValue(null)
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true }))
   })
 
   it('passes an abort signal into executeWorkflowWithFullLogging and aborts it', async () => {
@@ -92,4 +114,53 @@ describe('run tool execution cancellation', () => {
       })
     )
   })
+
+  it('prefers workflow_input, forwards triggerBlockId, and respects useDeployedState', async () => {
+    executeWorkflowWithFullLogging.mockResolvedValueOnce({
+      success: true,
+      output: { ok: true },
+      logs: [],
+    })
+
+    executeRunToolOnClient('tool-2', 'run_workflow', {
+      workflowId: 'wf-1',
+      workflow_input: { prompt: 'preferred' },
+      input: { prompt: 'fallback' },
+      triggerBlockId: 'trigger-1',
+      useDeployedState: true,
+    })
+
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(executeWorkflowWithFullLogging).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workflowId: 'wf-1',
+        workflowInput: { prompt: 'preferred' },
+        overrideTriggerType: 'copilot',
+        triggerBlockId: 'trigger-1',
+        useDraftState: false,
+      })
+    )
+  })
+
+  it('binds a recovered execution without starting a new workflow run', async () => {
+    loadExecutionPointer.mockResolvedValueOnce({
+      workflowId: 'wf-1',
+      executionId: 'exec-existing',
+      lastEventId: 7,
+    })
+
+    await expect(bindRunToolToExecution('tool-3', 'wf-1')).resolves.toBe(true)
+
+    expect(setActiveWorkflow).toHaveBeenCalledWith('wf-1')
+    expect(setIsExecuting).toHaveBeenCalledWith('wf-1', true)
+    expect(setCurrentExecutionId).toHaveBeenCalledWith('wf-1', 'exec-existing')
+    expect(saveExecutionPointer).toHaveBeenCalledWith({
+      workflowId: 'wf-1',
+      executionId: 'exec-existing',
+      lastEventId: 7,
+    })
+    expect(executeWorkflowWithFullLogging).not.toHaveBeenCalled()
+  })
 })
diff --git a/apps/sim/lib/copilot/client-sse/run-tool-execution.ts b/apps/sim/lib/copilot/tools/client/run-tool-execution.ts
similarity index 69%
rename from apps/sim/lib/copilot/client-sse/run-tool-execution.ts
rename to apps/sim/lib/copilot/tools/client/run-tool-execution.ts
index 2e22fcf6a78..5aca48a629a 100644
--- a/apps/sim/lib/copilot/client-sse/run-tool-execution.ts
+++ b/apps/sim/lib/copilot/tools/client/run-tool-execution.ts
@@ -1,10 +1,24 @@
 import { createLogger } from '@sim/logger'
+import type { AsyncCompletionData } from '@/lib/copilot/async-runs/lifecycle'
 import { COPILOT_CONFIRM_API_PATH } from '@/lib/copilot/constants'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  RunBlock,
+  RunFromBlock,
+  RunWorkflowUntilBlock,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-display-registry'
 import { generateId } from '@/lib/core/utils/uuid'
 import { executeWorkflowWithFullLogging } from '@/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils'
 import { useExecutionStore } from '@/stores/execution/store'
-import { clearExecutionPointer, consolePersistence, saveExecutionPointer } from '@/stores/terminal'
+import {
+  clearExecutionPointer,
+  consolePersistence,
+  type ExecutionPointer,
+  loadExecutionPointer,
+  saveExecutionPointer,
+  useTerminalConsoleStore,
+} from '@/stores/terminal'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 
 const logger = createLogger('CopilotRunToolExecution')
@@ -12,6 +26,102 @@ const activeRunToolByWorkflowId = new Map<string, string>()
 const activeRunAbortByWorkflowId = new Map<string, AbortController>()
 const manuallyStoppedToolCallIds = new Set<string>()
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function resolveWorkflowInput(params: Record<string, unknown>): unknown {
+  if (Object.hasOwn(params, 'workflow_input')) {
+    return params.workflow_input
+  }
+  if (Object.hasOwn(params, 'input')) {
+    return params.input
+  }
+  return undefined
+}
+
+function resolveTriggerBlockId(params: Record<string, unknown>): string | undefined {
+  return typeof params.triggerBlockId === 'string' && params.triggerBlockId.length > 0
+    ? params.triggerBlockId
+    : undefined
+}
+
+function getRunningExecutionPointer(workflowId: string): ExecutionPointer | null {
+  const runningEntries = useTerminalConsoleStore
+    .getState()
+    .getWorkflowEntries(workflowId)
+    .filter((entry) => entry.isRunning && entry.executionId)
+
+  if (runningEntries.length === 0) {
+    return null
+  }
+
+  const latestEntry = [...runningEntries].sort((a, b) => {
+    const aStartedAt = a.startedAt ? new Date(a.startedAt).getTime() : 0
+    const bStartedAt = b.startedAt ? new Date(b.startedAt).getTime() : 0
+    return bStartedAt - aStartedAt
+  })[0]
+
+  const executionId = latestEntry?.executionId
+  if (!executionId) {
+    return null
+  }
+
+  return {
+    workflowId,
+    executionId,
+    lastEventId: 0,
+  }
+}
+
+async function findRecoverableExecutionPointer(
+  workflowId: string
+): Promise<ExecutionPointer | null> {
+  const pointer = await loadExecutionPointer(workflowId)
+  if (pointer?.executionId) {
+    return pointer
+  }
+
+  return getRunningExecutionPointer(workflowId)
+}
+
+export async function bindRunToolToExecution(
+  toolCallId: string,
+  workflowId: string
+): Promise<boolean> {
+  const executionPointer = await findRecoverableExecutionPointer(workflowId)
+  if (!executionPointer) {
+    return false
+  }
+
+  const existingToolCallId = activeRunToolByWorkflowId.get(workflowId)
+  if (existingToolCallId && existingToolCallId !== toolCallId) {
+    logger.warn('[RunTool] Recovery skipped: another run tool is already active', {
+      workflowId,
+      toolCallId,
+      existingToolCallId,
+    })
+    return false
+  }
+
+  useWorkflowRegistry.getState().setActiveWorkflow(workflowId)
+  activeRunToolByWorkflowId.set(workflowId, toolCallId)
+
+  const { setCurrentExecutionId, setIsExecuting } = useExecutionStore.getState()
+  setIsExecuting(workflowId, true)
+  setCurrentExecutionId(workflowId, executionPointer.executionId)
+  saveExecutionPointer(executionPointer)
+
+  logger.info('[RunTool] Reattached tool call to existing workflow execution', {
+    workflowId,
+    toolCallId,
+    executionId: executionPointer.executionId,
+    lastEventId: executionPointer.lastEventId,
+  })
+
+  return true
+}
+
 /**
  * Execute a run tool on the client side using the streaming execute endpoint.
  * This gives full interactive feedback: block pulsing, console logs, stop button.
@@ -50,10 +160,17 @@ export function markRunToolManuallyStopped(workflowId: string): string | null {
   return toolCallId
 }
 
+export function isRunToolActiveForId(toolCallId: string): boolean {
+  for (const activeId of activeRunToolByWorkflowId.values()) {
+    if (activeId === toolCallId) return true
+  }
+  return false
+}
+
 export function cancelRunToolExecution(workflowId: string): void {
   const controller = activeRunAbortByWorkflowId.get(workflowId)
   if (!controller) return
-  controller.abort()
+  controller.abort('user_stop:cancelRunToolExecution')
   activeRunAbortByWorkflowId.delete(workflowId)
 }
 
@@ -76,7 +193,7 @@ export async function reportManualRunToolStop(
 
   await reportCompletion(
     toolCallId,
-    'cancelled',
+    MothershipStreamV1ToolOutcome.cancelled,
     'Workflow execution was stopped manually by the user.',
     {
       reason: 'user_cancelled',
@@ -100,7 +217,26 @@ async function doExecuteRunTool(
   if (!targetWorkflowId) {
     logger.warn('[RunTool] Execution prevented: no active workflow', { toolCallId, toolName })
     setToolState(toolCallId, ClientToolCallState.error)
-    await reportCompletion(toolCallId, 'error', 'No active workflow found')
+    await reportCompletion(
+      toolCallId,
+      MothershipStreamV1ToolOutcome.error,
+      'No active workflow found'
+    )
+    return
+  }
+
+  const existingToolCallId = activeRunToolByWorkflowId.get(targetWorkflowId)
+  if (existingToolCallId) {
+    logger.warn('[RunTool] Execution prevented: another run tool is already active', {
+      toolCallId,
+      toolName,
+      existingToolCallId,
+    })
+    await reportCompletion(
+      toolCallId,
+      MothershipStreamV1ToolOutcome.error,
+      'Workflow is already being executed by another tool. Wait for it to complete.'
+    )
     return
   }
 
@@ -112,31 +248,35 @@ async function doExecuteRunTool(
 
   if (isExecuting) {
     logger.warn('[RunTool] Execution prevented: already executing', { toolCallId, toolName })
+    activeRunToolByWorkflowId.delete(targetWorkflowId)
     setToolState(toolCallId, ClientToolCallState.error)
-    await reportCompletion(toolCallId, 'error', 'Workflow is already executing. Try again later')
+    await reportCompletion(
+      toolCallId,
+      MothershipStreamV1ToolOutcome.error,
+      'Workflow is already executing. Try again later'
+    )
     return
   }
 
   // Extract params for all tool types
-  const workflowInput = (params.workflow_input || params.input || undefined) as
-    | Record<string, unknown>
-    | undefined
+  const workflowInput = resolveWorkflowInput(params)
+  const triggerBlockId = resolveTriggerBlockId(params)
+  const useDraftState = params.useDeployedState !== true
 
   const stopAfterBlockId = (() => {
-    if (toolName === 'run_workflow_until_block')
-      return params.stopAfterBlockId as string | undefined
-    if (toolName === 'run_block') return params.blockId as string | undefined
+    if (toolName === RunWorkflowUntilBlock.id) return params.stopAfterBlockId as string | undefined
+    if (toolName === RunBlock.id) return params.blockId as string | undefined
     return undefined
   })()
 
   const runFromBlock = (() => {
-    if (toolName === 'run_from_block' && params.startBlockId) {
+    if (toolName === RunFromBlock.id && params.startBlockId) {
       return {
         startBlockId: params.startBlockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',
       }
     }
-    if (toolName === 'run_block' && params.blockId) {
+    if (toolName === RunBlock.id && params.blockId) {
       return {
         startBlockId: params.blockId as string,
         executionId: (params.executionId as string | undefined) || 'latest',
@@ -182,6 +322,8 @@ async function doExecuteRunTool(
     executionId,
     workflowId: targetWorkflowId,
     hasInput: !!workflowInput,
+    triggerBlockId,
+    useDraftState,
     stopAfterBlockId,
     runFromBlock: runFromBlock ? { startBlockId: runFromBlock.startBlockId } : undefined,
   })
@@ -192,6 +334,8 @@ async function doExecuteRunTool(
       workflowInput,
       executionId,
       overrideTriggerType: 'copilot',
+      triggerBlockId,
+      useDraftState,
       stopAfterBlockId,
       runFromBlock,
       abortSignal: abortController.signal,
@@ -230,7 +374,7 @@ async function doExecuteRunTool(
       setToolState(toolCallId, ClientToolCallState.success)
       await reportCompletion(
         toolCallId,
-        'success',
+        MothershipStreamV1ToolOutcome.success,
         `Workflow execution completed. Started at: ${executionStartTime}`,
         buildResultData(result)
       )
@@ -238,7 +382,12 @@ async function doExecuteRunTool(
       const msg = errorMessage || 'Workflow execution failed'
       logger.error('[RunTool] Workflow execution failed', { toolCallId, toolName, error: msg })
       setToolState(toolCallId, ClientToolCallState.error)
-      await reportCompletion(toolCallId, 'error', msg, buildResultData(result))
+      await reportCompletion(
+        toolCallId,
+        MothershipStreamV1ToolOutcome.error,
+        msg,
+        buildResultData(result)
+      )
     }
   } catch (err) {
     if (manuallyStoppedToolCallIds.has(toolCallId)) {
@@ -250,7 +399,7 @@ async function doExecuteRunTool(
       const msg = err instanceof Error ? err.message : String(err)
       logger.error('[RunTool] Workflow execution threw', { toolCallId, toolName, error: msg })
       setToolState(toolCallId, ClientToolCallState.error)
-      await reportCompletion(toolCallId, 'error', msg)
+      await reportCompletion(toolCallId, MothershipStreamV1ToolOutcome.error, msg)
     }
   } finally {
     if (typeof window !== 'undefined') {
@@ -315,28 +464,25 @@ function buildResultData(result: unknown): Record<string, unknown> | undefined {
  */
 async function reportCompletion(
   toolCallId: string,
-  status: 'success' | 'error' | 'cancelled',
+  status: MothershipStreamV1ToolOutcome,
   message?: string,
-  data?: Record<string, unknown>
+  data?: AsyncCompletionData
 ): Promise<void> {
   try {
     const body = JSON.stringify({
       toolCallId,
       status,
       message: message || (status === 'success' ? 'Tool completed' : 'Tool failed'),
-      ...(data ? { data } : {}),
+      ...(data !== undefined ? { data } : {}),
     })
     const res = await fetch(COPILOT_CONFIRM_API_PATH, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body,
     })
-    // Next.js silently truncates request bodies beyond its body size limit (default 10MB),
-    // corrupting the JSON and causing a server-side parse error (500). When the request fails
-    // and the payload is large, retry without logs (the largest field) to fit under the limit.
     const LARGE_PAYLOAD_THRESHOLD = 10 * 1024 * 1024
     const bodySize = new Blob([body]).size
-    if (!res.ok && data && bodySize > LARGE_PAYLOAD_THRESHOLD) {
+    if (!res.ok && isRecord(data) && bodySize > LARGE_PAYLOAD_THRESHOLD) {
       const { logs: _logs, ...dataWithoutLogs } = data
       logger.warn('[RunTool] reportCompletion failed with large payload, retrying without logs', {
         toolCallId,
diff --git a/apps/sim/lib/copilot/store-utils.ts b/apps/sim/lib/copilot/tools/client/store-utils.ts
similarity index 82%
rename from apps/sim/lib/copilot/store-utils.ts
rename to apps/sim/lib/copilot/tools/client/store-utils.ts
index 9447f9cbf11..299764201a6 100644
--- a/apps/sim/lib/copilot/store-utils.ts
+++ b/apps/sim/lib/copilot/tools/client/store-utils.ts
@@ -23,7 +23,9 @@ import {
   Wrench,
   Zap,
 } from 'lucide-react'
-import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resource-types'
+import { Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resources/types'
+import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
 import {
   ClientToolCallState,
   type ClientToolDisplay,
@@ -34,8 +36,7 @@ const logger = createLogger('CopilotStoreUtils')
 
 /** Respond tools are internal handoff tools shown with a friendly generic label. */
 const HIDDEN_TOOL_SUFFIX = '_respond'
-const HIDDEN_TOOL_NAMES = new Set(['tool_search_tool_regex'])
-
+const INTERNAL_RESPOND_TOOL = 'respond'
 /** UI metadata sent by the copilot on SSE tool_call events. */
 export interface ServerToolUI {
   title?: string
@@ -83,7 +84,7 @@ export function resolveToolDisplay(
   serverUI?: ServerToolUI
 ): ClientToolDisplay | undefined {
   if (!toolName) return undefined
-  if (HIDDEN_TOOL_NAMES.has(toolName)) return undefined
+  if (isToolHiddenInUi(toolName)) return undefined
 
   const specialDisplay = specialToolDisplay(toolName, state, params)
   if (specialDisplay) return specialDisplay
@@ -126,14 +127,14 @@ function specialToolDisplay(
   state: ClientToolCallState,
   params?: Record<string, unknown>
 ): ClientToolDisplay | undefined {
-  if (toolName.endsWith(HIDDEN_TOOL_SUFFIX)) {
+  if (toolName === INTERNAL_RESPOND_TOOL || toolName.endsWith(HIDDEN_TOOL_SUFFIX)) {
     return {
       text: formatRespondLabel(state),
       icon: Loader2,
     }
   }
 
-  if (toolName === 'read') {
+  if (toolName === ReadTool.id) {
     const target = describeReadTarget(readStringParam(params, 'path'))
     return {
       text: formatReadingLabel(target, state),
@@ -145,17 +146,8 @@ function specialToolDisplay(
 }
 
 function formatRespondLabel(state: ClientToolCallState): string {
-  switch (state) {
-    case ClientToolCallState.success:
-      return 'Returned results'
-    case ClientToolCallState.error:
-      return 'Failed returning results'
-    case ClientToolCallState.rejected:
-    case ClientToolCallState.aborted:
-      return 'Skipped returning results'
-    default:
-      return 'Returning results'
-  }
+  void state
+  return 'Gathering thoughts'
 }
 
 function readStringParam(
@@ -227,7 +219,7 @@ function serverUIFallback(serverUI: ServerToolUI, state: ClientToolCallState): C
   }
 }
 
-export function humanizedFallback(
+function humanizedFallback(
   toolName: string,
   state: ClientToolCallState
 ): ClientToolDisplay | undefined {
@@ -244,7 +236,7 @@ export function humanizedFallback(
 }
 
 export function isRejectedState(state: string): boolean {
-  return state === 'rejected'
+  return state === ClientToolCallState.rejected
 }
 
 export function isReviewState(state: string): boolean {
@@ -254,24 +246,3 @@ export function isReviewState(state: string): boolean {
 export function isBackgroundState(state: string): boolean {
   return state === 'background'
 }
-
-export function isTerminalState(state: string): boolean {
-  return (
-    state === ClientToolCallState.success ||
-    state === ClientToolCallState.error ||
-    state === ClientToolCallState.rejected ||
-    state === ClientToolCallState.aborted ||
-    isReviewState(state) ||
-    isBackgroundState(state)
-  )
-}
-
-export function stripTodoTags(text: string): string {
-  if (!text) return text
-  return text
-    .replace(/<marktodo>[\s\S]*?<\/marktodo>/g, '')
-    .replace(/<checkofftodo>[\s\S]*?<\/checkofftodo>/g, '')
-    .replace(/<design_workflow>[\s\S]*?<\/design_workflow>/g, '')
-    .replace(/[ \t]+\n/g, '\n')
-    .replace(/\n{2,}/g, '\n')
-}
diff --git a/apps/sim/lib/copilot/tools/client/tool-display-registry.ts b/apps/sim/lib/copilot/tools/client/tool-display-registry.ts
index cad83d1ec4c..e5fcaec3729 100644
--- a/apps/sim/lib/copilot/tools/client/tool-display-registry.ts
+++ b/apps/sim/lib/copilot/tools/client/tool-display-registry.ts
@@ -1,10 +1,8 @@
 import type { LucideIcon } from 'lucide-react'
 import {
   BookOpen,
-  Bug,
   Check,
   CheckCircle,
-  ClipboardList,
   Database,
   Eye,
   FileSearch,
@@ -12,7 +10,6 @@ import {
   FolderPlus,
   GitBranch,
   Globe,
-  Globe2,
   Grid2x2,
   Grid2x2Check,
   Grid2x2X,
@@ -40,6 +37,11 @@ import {
   XCircle,
   Zap,
 } from 'lucide-react'
+import {
+  ManageCustomToolOperation,
+  ManageMcpToolOperation,
+  ManageSkillOperation,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import { getQueryClient } from '@/app/_shell/providers/get-query-client'
 import type { CustomToolDefinition } from '@/hooks/queries/custom-tools'
 import type { WorkflowDeploymentInfo } from '@/hooks/queries/deployments'
@@ -229,6 +231,15 @@ const META_check_deployment_status: ToolMetadata = {
   interrupt: undefined,
 }
 
+const META_complete_job: ToolMetadata = {
+  displayNames: {
+    [ClientToolCallState.generating]: { text: 'Completing job', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Completing job', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Completed job', icon: CheckCircle },
+    [ClientToolCallState.error]: { text: 'Failed to complete job', icon: XCircle },
+  },
+}
+
 const META_checkoff_todo: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: { text: 'Marking todo', icon: Loader2 },
@@ -272,6 +283,30 @@ const META_crawl_website: ToolMetadata = {
   },
 }
 
+const META_create_file: ToolMetadata = {
+  displayNames: {
+    [ClientToolCallState.generating]: { text: 'Creating file', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Creating file', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Created file', icon: FileText },
+    [ClientToolCallState.error]: { text: 'Failed to create file', icon: XCircle },
+  },
+  getDynamicText: (params, state) => {
+    const fileName = params?.fileName
+    if (typeof fileName !== 'string' || !fileName.trim()) return undefined
+
+    switch (state) {
+      case ClientToolCallState.success:
+        return `Created ${fileName}`
+      case ClientToolCallState.executing:
+      case ClientToolCallState.generating:
+        return `Creating ${fileName}`
+      case ClientToolCallState.error:
+        return `Failed to create ${fileName}`
+    }
+    return undefined
+  },
+}
+
 const META_create_workspace_mcp_server: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: {
@@ -350,19 +385,19 @@ const META_agent: ToolMetadata = {
 const META_manage_skill: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: {
-      text: 'Managing skill',
+      text: 'Skill action',
       icon: Loader2,
     },
-    [ClientToolCallState.pending]: { text: 'Manage skill?', icon: BookOpen },
-    [ClientToolCallState.executing]: { text: 'Managing skill', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Managed skill', icon: Check },
-    [ClientToolCallState.error]: { text: 'Failed to manage skill', icon: X },
+    [ClientToolCallState.pending]: { text: 'Skill action?', icon: BookOpen },
+    [ClientToolCallState.executing]: { text: 'Skill action', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Updated skill', icon: Check },
+    [ClientToolCallState.error]: { text: 'Failed skill action', icon: X },
     [ClientToolCallState.aborted]: {
-      text: 'Aborted managing skill',
+      text: 'Aborted skill action',
       icon: XCircle,
     },
     [ClientToolCallState.rejected]: {
-      text: 'Skipped managing skill',
+      text: 'Skipped skill action',
       icon: XCircle,
     },
   },
@@ -370,22 +405,82 @@ const META_manage_skill: ToolMetadata = {
     accept: { text: 'Allow', icon: Check },
     reject: { text: 'Deny', icon: X },
   },
+  getDynamicText: (params, state) => {
+    const operation = params?.operation as ManageSkillOperation | undefined
+    if (!operation) return undefined
+
+    const skillName = typeof params?.name === 'string' ? params.name : 'skill'
+
+    switch (state) {
+      case ClientToolCallState.success:
+        switch (operation) {
+          case ManageSkillOperation.add:
+            return `Created ${skillName}`
+          case ManageSkillOperation.edit:
+            return `Updated ${skillName}`
+          case ManageSkillOperation.delete:
+            return `Deleted ${skillName}`
+          case ManageSkillOperation.list:
+            return 'Listed skills'
+        }
+        break
+      case ClientToolCallState.executing:
+      case ClientToolCallState.generating:
+        switch (operation) {
+          case ManageSkillOperation.add:
+            return `Creating ${skillName}`
+          case ManageSkillOperation.edit:
+            return `Updating ${skillName}`
+          case ManageSkillOperation.delete:
+            return `Deleting ${skillName}`
+          case ManageSkillOperation.list:
+            return 'Listing skills'
+        }
+        break
+      case ClientToolCallState.pending:
+        switch (operation) {
+          case ManageSkillOperation.add:
+            return `Create ${skillName}?`
+          case ManageSkillOperation.edit:
+            return `Update ${skillName}?`
+          case ManageSkillOperation.delete:
+            return `Delete ${skillName}?`
+          case ManageSkillOperation.list:
+            return 'List skills?'
+        }
+        break
+      case ClientToolCallState.error:
+        switch (operation) {
+          case ManageSkillOperation.add:
+            return `Failed to create ${skillName}`
+          case ManageSkillOperation.edit:
+            return `Failed to update ${skillName}`
+          case ManageSkillOperation.delete:
+            return `Failed to delete ${skillName}`
+          case ManageSkillOperation.list:
+            return 'Failed to list skills'
+        }
+        break
+    }
+
+    return undefined
+  },
 }
 
-const META_build: ToolMetadata = {
+const META_workflow: ToolMetadata = {
   displayNames: {
-    [ClientToolCallState.generating]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Built', icon: Wrench },
-    [ClientToolCallState.error]: { text: 'Failed to build', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped build', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted build', icon: XCircle },
+    [ClientToolCallState.generating]: { text: 'Managing workflow', icon: Loader2 },
+    [ClientToolCallState.pending]: { text: 'Managing workflow', icon: Loader2 },
+    [ClientToolCallState.executing]: { text: 'Managing workflow', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Done', icon: Wrench },
+    [ClientToolCallState.error]: { text: 'Failed', icon: XCircle },
+    [ClientToolCallState.rejected]: { text: 'Skipped', icon: XCircle },
+    [ClientToolCallState.aborted]: { text: 'Aborted', icon: XCircle },
   },
   uiConfig: {
     subagent: {
-      streamingLabel: 'Building',
-      completedLabel: 'Built',
+      streamingLabel: 'Managing workflow',
+      completedLabel: 'Done',
       shouldCollapse: true,
       outputArtifacts: [],
     },
@@ -961,87 +1056,22 @@ const META_list_workspace_mcp_servers: ToolMetadata = {
   interrupt: undefined,
 }
 
-const META_make_api_request: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Preparing API request', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Review API request', icon: Globe2 },
-    [ClientToolCallState.executing]: { text: 'Executing API request', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Completed API request', icon: Globe2 },
-    [ClientToolCallState.error]: { text: 'Failed to execute API request', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped API request', icon: MinusCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted API request', icon: XCircle },
-  },
-  interrupt: {
-    accept: { text: 'Execute', icon: Globe2 },
-    reject: { text: 'Skip', icon: MinusCircle },
-  },
-  uiConfig: {
-    interrupt: {
-      accept: { text: 'Execute', icon: Globe2 },
-      reject: { text: 'Skip', icon: MinusCircle },
-      showAllowOnce: true,
-      showAllowAlways: true,
-    },
-    paramsTable: {
-      columns: [
-        { key: 'method', label: 'Method', width: '26%', editable: true, mono: true },
-        { key: 'url', label: 'Endpoint', width: '74%', editable: true, mono: true },
-      ],
-      extractRows: (params: Record<string, any>): Array<[string, ...any[]]> => {
-        return [['request', (params.method || 'GET').toUpperCase(), params.url || '']]
-      },
-    },
-  },
-  getDynamicText: (params, state) => {
-    if (params?.url && typeof params.url === 'string') {
-      const method = params.method || 'GET'
-      let url = params.url
-
-      // Extract domain from URL for cleaner display
-      try {
-        const urlObj = new URL(url)
-        url = urlObj.hostname + urlObj.pathname
-      } catch {
-        // Use URL as-is if parsing fails
-      }
-
-      switch (state) {
-        case ClientToolCallState.success:
-          return `${method} ${url} complete`
-        case ClientToolCallState.executing:
-          return `${method} ${url}`
-        case ClientToolCallState.generating:
-          return `Preparing ${method} ${url}`
-        case ClientToolCallState.pending:
-          return `Review ${method} ${url}`
-        case ClientToolCallState.error:
-          return `Failed ${method} ${url}`
-        case ClientToolCallState.rejected:
-          return `Skipped ${method} ${url}`
-        case ClientToolCallState.aborted:
-          return `Aborted ${method} ${url}`
-      }
-    }
-    return undefined
-  },
-}
-
 const META_manage_custom_tool: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: {
-      text: 'Managing custom tool',
+      text: 'Custom tool action',
       icon: Loader2,
     },
-    [ClientToolCallState.pending]: { text: 'Manage custom tool?', icon: Plus },
-    [ClientToolCallState.executing]: { text: 'Managing custom tool', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Managed custom tool', icon: Check },
-    [ClientToolCallState.error]: { text: 'Failed to manage custom tool', icon: X },
+    [ClientToolCallState.pending]: { text: 'Custom tool action?', icon: Plus },
+    [ClientToolCallState.executing]: { text: 'Custom tool action', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Updated custom tool', icon: Check },
+    [ClientToolCallState.error]: { text: 'Failed custom tool action', icon: X },
     [ClientToolCallState.aborted]: {
-      text: 'Aborted managing custom tool',
+      text: 'Aborted custom tool action',
       icon: XCircle,
     },
     [ClientToolCallState.rejected]: {
-      text: 'Skipped managing custom tool',
+      text: 'Skipped custom tool action',
       icon: XCircle,
     },
   },
@@ -1050,7 +1080,7 @@ const META_manage_custom_tool: ToolMetadata = {
     reject: { text: 'Skip', icon: XCircle },
   },
   getDynamicText: (params, state) => {
-    const operation = params?.operation as 'add' | 'edit' | 'delete' | 'list' | undefined
+    const operation = params?.operation as ManageCustomToolOperation | undefined
     const workspaceId = getScopedWorkspaceId(params)
 
     if (!operation) return undefined
@@ -1071,13 +1101,13 @@ const META_manage_custom_tool: ToolMetadata = {
 
     const getActionText = (verb: 'present' | 'past' | 'gerund') => {
       switch (operation) {
-        case 'add':
+        case ManageCustomToolOperation.add:
           return verb === 'present' ? 'Create' : verb === 'past' ? 'Created' : 'Creating'
-        case 'edit':
+        case ManageCustomToolOperation.edit:
           return verb === 'present' ? 'Edit' : verb === 'past' ? 'Edited' : 'Editing'
-        case 'delete':
+        case ManageCustomToolOperation.delete:
           return verb === 'present' ? 'Delete' : verb === 'past' ? 'Deleted' : 'Deleting'
-        case 'list':
+        case ManageCustomToolOperation.list:
           return verb === 'present' ? 'List' : verb === 'past' ? 'Listed' : 'Listing'
         default:
           return verb === 'present' ? 'Manage' : verb === 'past' ? 'Managed' : 'Managing'
@@ -1088,15 +1118,15 @@ const META_manage_custom_tool: ToolMetadata = {
     // For edit/delete: always show tool name
     // For list: never show individual tool name, use plural
     const shouldShowToolName = (currentState: ClientToolCallState) => {
-      if (operation === 'list') return false
-      if (operation === 'add') {
+      if (operation === ManageCustomToolOperation.list) return false
+      if (operation === ManageCustomToolOperation.add) {
         return currentState === ClientToolCallState.success
       }
       return true // edit and delete always show tool name
     }
 
     const nameText =
-      operation === 'list'
+      operation === ManageCustomToolOperation.list
         ? ' custom tools'
         : shouldShowToolName(state) && toolName
           ? ` ${toolName}`
@@ -1125,19 +1155,19 @@ const META_manage_custom_tool: ToolMetadata = {
 const META_manage_mcp_tool: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: {
-      text: 'Managing MCP tool',
+      text: 'MCP server action',
       icon: Loader2,
     },
-    [ClientToolCallState.pending]: { text: 'Manage MCP tool?', icon: Server },
-    [ClientToolCallState.executing]: { text: 'Managing MCP tool', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Managed MCP tool', icon: Check },
-    [ClientToolCallState.error]: { text: 'Failed to manage MCP tool', icon: X },
+    [ClientToolCallState.pending]: { text: 'MCP server action?', icon: Server },
+    [ClientToolCallState.executing]: { text: 'MCP server action', icon: Loader2 },
+    [ClientToolCallState.success]: { text: 'Updated MCP server', icon: Check },
+    [ClientToolCallState.error]: { text: 'Failed MCP server action', icon: X },
     [ClientToolCallState.aborted]: {
-      text: 'Aborted managing MCP tool',
+      text: 'Aborted MCP server action',
       icon: XCircle,
     },
     [ClientToolCallState.rejected]: {
-      text: 'Skipped managing MCP tool',
+      text: 'Skipped MCP server action',
       icon: XCircle,
     },
   },
@@ -1146,7 +1176,7 @@ const META_manage_mcp_tool: ToolMetadata = {
     reject: { text: 'Skip', icon: XCircle },
   },
   getDynamicText: (params, state) => {
-    const operation = params?.operation as 'add' | 'edit' | 'delete' | undefined
+    const operation = params?.operation as ManageMcpToolOperation | undefined
 
     if (!operation) return undefined
 
@@ -1154,23 +1184,31 @@ const META_manage_mcp_tool: ToolMetadata = {
 
     const getActionText = (verb: 'present' | 'past' | 'gerund') => {
       switch (operation) {
-        case 'add':
+        case ManageMcpToolOperation.add:
           return verb === 'present' ? 'Add' : verb === 'past' ? 'Added' : 'Adding'
-        case 'edit':
+        case ManageMcpToolOperation.edit:
           return verb === 'present' ? 'Edit' : verb === 'past' ? 'Edited' : 'Editing'
-        case 'delete':
+        case ManageMcpToolOperation.delete:
           return verb === 'present' ? 'Delete' : verb === 'past' ? 'Deleted' : 'Deleting'
+        case ManageMcpToolOperation.list:
+          return verb === 'present' ? 'List' : verb === 'past' ? 'Listed' : 'Listing'
       }
     }
 
     const shouldShowServerName = (currentState: ClientToolCallState) => {
-      if (operation === 'add') {
+      if (operation === ManageMcpToolOperation.list) return false
+      if (operation === ManageMcpToolOperation.add) {
         return currentState === ClientToolCallState.success
       }
       return true
     }
 
-    const nameText = shouldShowServerName(state) && serverName ? ` ${serverName}` : ' MCP tool'
+    const nameText =
+      operation === ManageMcpToolOperation.list
+        ? ' MCP servers'
+        : shouldShowServerName(state) && serverName
+          ? ` ${serverName}`
+          : ' MCP server'
 
     switch (state) {
       case ClientToolCallState.success:
@@ -2087,86 +2125,6 @@ const META_superagent: ToolMetadata = {
   },
 }
 
-const META_plan: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Planning', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Planning', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Planning', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Planned', icon: ClipboardList },
-    [ClientToolCallState.error]: { text: 'Failed to plan', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped planning', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted planning', icon: XCircle },
-  },
-  uiConfig: {
-    subagent: {
-      streamingLabel: 'Planning',
-      completedLabel: 'Planned',
-      shouldCollapse: true,
-      outputArtifacts: [],
-    },
-  },
-}
-
-const META_edit: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Editing', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Editing', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Editing', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Edited', icon: PencilLine },
-    [ClientToolCallState.error]: { text: 'Failed to edit', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped editing', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted editing', icon: XCircle },
-  },
-  uiConfig: {
-    subagent: {
-      streamingLabel: 'Editing',
-      completedLabel: 'Edited',
-      shouldCollapse: true,
-      outputArtifacts: [],
-    },
-  },
-}
-
-const META_fast_edit: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Building', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Built', icon: Wrench },
-    [ClientToolCallState.error]: { text: 'Failed to build', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped build', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted build', icon: XCircle },
-  },
-  uiConfig: {
-    subagent: {
-      streamingLabel: 'Building',
-      completedLabel: 'Built',
-      shouldCollapse: true,
-      outputArtifacts: [],
-    },
-  },
-}
-
-const META_debug: ToolMetadata = {
-  displayNames: {
-    [ClientToolCallState.generating]: { text: 'Debugging', icon: Loader2 },
-    [ClientToolCallState.pending]: { text: 'Debugging', icon: Loader2 },
-    [ClientToolCallState.executing]: { text: 'Debugging', icon: Loader2 },
-    [ClientToolCallState.success]: { text: 'Debugged', icon: Bug },
-    [ClientToolCallState.error]: { text: 'Failed to debug', icon: XCircle },
-    [ClientToolCallState.rejected]: { text: 'Skipped debugging', icon: XCircle },
-    [ClientToolCallState.aborted]: { text: 'Aborted debugging', icon: XCircle },
-  },
-  uiConfig: {
-    subagent: {
-      streamingLabel: 'Debugging',
-      completedLabel: 'Debugged',
-      shouldCollapse: true,
-      outputArtifacts: [],
-    },
-  },
-}
-
 const META_table: ToolMetadata = {
   displayNames: {
     [ClientToolCallState.generating]: { text: 'Managing tables', icon: Loader2 },
@@ -2356,21 +2314,20 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   auth: META_auth,
   context_compaction: META_context_compaction,
   check_deployment_status: META_check_deployment_status,
+  complete_job: META_complete_job,
   checkoff_todo: META_checkoff_todo,
   crawl_website: META_crawl_website,
+  create_file: META_create_file,
   create_workspace_mcp_server: META_create_workspace_mcp_server,
-  build: META_build,
+  workflow: META_workflow,
   create_folder: META_create_folder,
   create_workflow: META_create_workflow,
   agent: META_agent,
   custom_tool: META_custom_tool,
-  debug: META_debug,
   deploy: META_deploy,
   deploy_api: META_deploy_api,
   deploy_chat: META_deploy_chat,
   deploy_mcp: META_deploy_mcp,
-  edit: META_edit,
-  fast_edit: META_fast_edit,
   edit_workflow: META_edit_workflow,
   get_block_outputs: META_get_block_outputs,
   get_block_upstream_references: META_get_block_upstream_references,
@@ -2390,7 +2347,6 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   list_folders: META_list_folders,
   list_user_workspaces: META_list_user_workspaces,
   list_workspace_mcp_servers: META_list_workspace_mcp_servers,
-  make_api_request: META_make_api_request,
   manage_custom_tool: META_manage_custom_tool,
   manage_mcp_tool: META_manage_mcp_tool,
   manage_skill: META_manage_skill,
@@ -2401,7 +2357,6 @@ const TOOL_METADATA_BY_ID: Record<string, ToolMetadata> = {
   oauth_get_auth_link: META_oauth_get_auth_link,
   oauth_request_access: META_oauth_request_access,
   open_resource: META_open_resource,
-  plan: META_plan,
   read: META_read,
   redeploy: META_redeploy,
   rename_workflow: META_rename_workflow,
diff --git a/apps/sim/lib/copilot/tool-descriptions.test.ts b/apps/sim/lib/copilot/tools/descriptions.test.ts
similarity index 97%
rename from apps/sim/lib/copilot/tool-descriptions.test.ts
rename to apps/sim/lib/copilot/tools/descriptions.test.ts
index df0a1183376..6bb7d11d037 100644
--- a/apps/sim/lib/copilot/tool-descriptions.test.ts
+++ b/apps/sim/lib/copilot/tools/descriptions.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { getCopilotToolDescription } from './descriptions'
 
 describe('getCopilotToolDescription', () => {
   it.concurrent('returns the base description when hosted keys are not active', () => {
diff --git a/apps/sim/lib/copilot/tool-descriptions.ts b/apps/sim/lib/copilot/tools/descriptions.ts
similarity index 100%
rename from apps/sim/lib/copilot/tool-descriptions.ts
rename to apps/sim/lib/copilot/tools/descriptions.ts
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/access.ts b/apps/sim/lib/copilot/tools/handlers/access.ts
similarity index 100%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/access.ts
rename to apps/sim/lib/copilot/tools/handlers/access.ts
diff --git a/apps/sim/lib/copilot/tools/handlers/context.ts b/apps/sim/lib/copilot/tools/handlers/context.ts
new file mode 100644
index 00000000000..e229c762c7c
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/context.ts
@@ -0,0 +1,26 @@
+import type { ExecutionContext } from '@/lib/copilot/request/types'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+import { getWorkflowById } from '@/lib/workflows/utils'
+
+export async function prepareExecutionContext(
+  userId: string,
+  workflowId: string,
+  chatId?: string,
+  options?: {
+    workspaceId?: string
+    decryptedEnvVars?: Record<string, string>
+  }
+): Promise<ExecutionContext> {
+  const workspaceId =
+    options?.workspaceId ?? (await getWorkflowById(workflowId))?.workspaceId ?? undefined
+  const decryptedEnvVars =
+    options?.decryptedEnvVars ?? (await getEffectiveDecryptedEnv(userId, workspaceId))
+
+  return {
+    userId,
+    workflowId,
+    workspaceId,
+    chatId,
+    decryptedEnvVars,
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
new file mode 100644
index 00000000000..8c990213724
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
@@ -0,0 +1,769 @@
+import { db } from '@sim/db'
+import { chat, workflowMcpServer, workflowMcpTool } from '@sim/db/schema'
+import { and, eq, isNull } from 'drizzle-orm'
+import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { getBaseUrl } from '@/lib/core/utils/urls'
+import { generateId } from '@/lib/core/utils/uuid'
+import { mcpPubSub } from '@/lib/mcp/pubsub'
+import { generateParameterSchemaForWorkflow } from '@/lib/mcp/workflow-mcp-sync'
+import { sanitizeToolName } from '@/lib/mcp/workflow-tool-schema'
+import {
+  performChatDeploy,
+  performChatUndeploy,
+  performFullDeploy,
+  performFullUndeploy,
+} from '@/lib/workflows/orchestration'
+import { checkChatAccess, checkWorkflowAccessForChatCreation } from '@/app/api/chat/utils'
+import { ensureWorkflowAccess } from '../access'
+import type { DeployApiParams, DeployChatParams, DeployMcpParams } from '../param-types'
+
+function buildWorkflowApiEndpoint(baseUrl: string, workflowId: string): string {
+  return `${baseUrl}/api/workflows/${workflowId}/execute`
+}
+
+function buildWorkflowApiConfig(baseUrl: string, apiEndpoint: string) {
+  return {
+    endpoint: apiEndpoint,
+    authentication: {
+      type: 'api_key',
+      acceptedHeaders: ['X-API-Key: YOUR_API_KEY', 'Authorization: Bearer YOUR_API_KEY'],
+    },
+    modes: {
+      sync: {
+        method: 'POST',
+        transport: 'json',
+        stream: false,
+        body: { input: { key: 'value' } },
+      },
+      stream: {
+        method: 'POST',
+        transport: 'sse',
+        stream: true,
+        body: { stream: true, input: { key: 'value' } },
+      },
+      async: {
+        method: 'POST',
+        transport: 'json',
+        stream: false,
+        headers: { 'X-Execution-Mode': 'async' },
+        body: { input: { key: 'value' } },
+        jobStatusEndpointTemplate: `${baseUrl}/api/jobs/{jobId}`,
+      },
+    },
+  }
+}
+
+function buildWorkflowApiExamples(baseUrl: string, apiEndpoint: string) {
+  return {
+    sync: `curl -X POST "${apiEndpoint}" \\
+  -H "Content-Type: application/json" \\
+  -H "X-API-Key: YOUR_API_KEY" \\
+  -d '{"input":{"key":"value"}}'`,
+    stream: `curl -N -X POST "${apiEndpoint}" \\
+  -H "Content-Type: application/json" \\
+  -H "X-API-Key: YOUR_API_KEY" \\
+  -d '{"stream":true,"input":{"key":"value"}}'`,
+    async: `curl -X POST "${apiEndpoint}" \\
+  -H "Content-Type: application/json" \\
+  -H "X-API-Key: YOUR_API_KEY" \\
+  -H "X-Execution-Mode: async" \\
+  -d '{"input":{"key":"value"}}'`,
+    poll: `curl "${baseUrl}/api/jobs/JOB_ID" \\
+  -H "X-API-Key: YOUR_API_KEY"`,
+  }
+}
+
+function buildMcpClientExamples(serverName: string, serverUrl: string) {
+  return {
+    cursor: {
+      mcpServers: {
+        [serverName]: {
+          url: serverUrl,
+          headers: { 'X-API-Key': 'YOUR_API_KEY' },
+        },
+      },
+    },
+    claudeCode: `claude mcp add ${serverName} --url "${serverUrl}" --header "X-API-Key: YOUR_API_KEY"`,
+    claudeDesktop: {
+      mcpServers: {
+        [serverName]: {
+          command: 'npx',
+          args: ['-y', 'mcp-remote', serverUrl, '--header', 'X-API-Key:YOUR_API_KEY'],
+        },
+      },
+    },
+    vscode: {
+      mcp: {
+        servers: {
+          [serverName]: {
+            type: 'http',
+            url: serverUrl,
+            headers: { 'X-API-Key': 'YOUR_API_KEY' },
+          },
+        },
+      },
+    },
+  }
+}
+
+export async function executeDeployApi(
+  params: DeployApiParams,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  try {
+    const workflowId = params.workflowId || context.workflowId
+    if (!workflowId) {
+      return { success: false, error: 'workflowId is required' }
+    }
+    const action = params.action === 'undeploy' ? 'undeploy' : 'deploy'
+    const { workflow: workflowRecord } = await ensureWorkflowAccess(
+      workflowId,
+      context.userId,
+      'admin'
+    )
+
+    if (action === 'undeploy') {
+      const result = await performFullUndeploy({ workflowId, userId: context.userId })
+      if (!result.success) {
+        return { success: false, error: result.error || 'Failed to undeploy workflow' }
+      }
+      const baseUrl = getBaseUrl()
+      const apiEndpoint = buildWorkflowApiEndpoint(baseUrl, workflowId)
+      return {
+        success: true,
+        output: {
+          workflowId,
+          isDeployed: false,
+          apiEndpoint,
+          baseUrl,
+          deploymentType: 'api',
+          deploymentStatus: {
+            api: {
+              isDeployed: false,
+              endpoint: apiEndpoint,
+            },
+          },
+          deploymentConfig: {
+            api: buildWorkflowApiConfig(baseUrl, apiEndpoint),
+          },
+          examples: {
+            api: {
+              curl: buildWorkflowApiExamples(baseUrl, apiEndpoint),
+            },
+          },
+        },
+      }
+    }
+
+    const result = await performFullDeploy({
+      workflowId,
+      userId: context.userId,
+      workflowName: workflowRecord.name || undefined,
+    })
+    if (!result.success) {
+      return { success: false, error: result.error || 'Failed to deploy workflow' }
+    }
+
+    const baseUrl = getBaseUrl()
+    const apiEndpoint = buildWorkflowApiEndpoint(baseUrl, workflowId)
+    const apiConfig = buildWorkflowApiConfig(baseUrl, apiEndpoint)
+    const apiExamples = buildWorkflowApiExamples(baseUrl, apiEndpoint)
+    return {
+      success: true,
+      output: {
+        workflowId,
+        isDeployed: true,
+        deployedAt: result.deployedAt,
+        version: result.version,
+        apiEndpoint,
+        baseUrl,
+        deploymentType: 'api',
+        deploymentStatus: {
+          api: {
+            isDeployed: true,
+            endpoint: apiEndpoint,
+            deployedAt: result.deployedAt,
+            version: result.version,
+          },
+        },
+        deploymentConfig: {
+          api: apiConfig,
+        },
+        examples: {
+          api: {
+            curl: apiExamples,
+          },
+        },
+      },
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export async function executeDeployChat(
+  params: DeployChatParams,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  try {
+    const workflowId = params.workflowId || context.workflowId
+    if (!workflowId) {
+      return { success: false, error: 'workflowId is required' }
+    }
+
+    const action = params.action === 'undeploy' ? 'undeploy' : 'deploy'
+    if (action === 'undeploy') {
+      const baseUrl = getBaseUrl()
+      const apiEndpoint = buildWorkflowApiEndpoint(baseUrl, workflowId)
+      const apiConfig = buildWorkflowApiConfig(baseUrl, apiEndpoint)
+      const apiExamples = buildWorkflowApiExamples(baseUrl, apiEndpoint)
+      const existing = await db
+        .select()
+        .from(chat)
+        .where(and(eq(chat.workflowId, workflowId), isNull(chat.archivedAt)))
+        .limit(1)
+      if (!existing.length) {
+        return { success: false, error: 'No active chat deployment found for this workflow' }
+      }
+      const { hasAccess, workspaceId: chatWorkspaceId } = await checkChatAccess(
+        existing[0].id,
+        context.userId
+      )
+      if (!hasAccess) {
+        return { success: false, error: 'Unauthorized chat access' }
+      }
+      const undeployResult = await performChatUndeploy({
+        chatId: existing[0].id,
+        userId: context.userId,
+        workspaceId: chatWorkspaceId,
+      })
+      if (!undeployResult.success) {
+        return { success: false, error: undeployResult.error || 'Failed to undeploy chat' }
+      }
+      return {
+        success: true,
+        output: {
+          workflowId,
+          success: true,
+          action: 'undeploy',
+          isDeployed: true,
+          isChatDeployed: false,
+          deploymentType: 'chat',
+          apiEndpoint,
+          baseUrl,
+          deploymentStatus: {
+            api: {
+              isDeployed: true,
+              endpoint: apiEndpoint,
+            },
+            chat: {
+              isDeployed: false,
+              identifier: existing[0].identifier,
+              title: existing[0].title,
+            },
+          },
+          deploymentConfig: {
+            api: apiConfig,
+            chat: {
+              identifier: existing[0].identifier,
+              title: existing[0].title,
+              description: existing[0].description || '',
+              authType: existing[0].authType,
+              allowedEmails: (existing[0].allowedEmails as string[]) || [],
+              outputConfigs:
+                (existing[0].outputConfigs as Array<{ blockId: string; path: string }>) || [],
+              welcomeMessage:
+                (existing[0].customizations as { welcomeMessage?: string } | null)
+                  ?.welcomeMessage || 'Hi there! How can I help you today?',
+            },
+          },
+          examples: {
+            api: {
+              curl: apiExamples,
+            },
+          },
+        },
+      }
+    }
+
+    const { hasAccess, workflow: workflowRecord } = await checkWorkflowAccessForChatCreation(
+      workflowId,
+      context.userId
+    )
+    if (!hasAccess || !workflowRecord) {
+      return { success: false, error: 'Workflow not found or access denied' }
+    }
+
+    const [existingDeployment] = await db
+      .select()
+      .from(chat)
+      .where(and(eq(chat.workflowId, workflowId), isNull(chat.archivedAt)))
+      .limit(1)
+
+    const identifier = String(params.identifier || existingDeployment?.identifier || '').trim()
+    const title = String(params.title || existingDeployment?.title || '').trim()
+    if (!identifier || !title) {
+      return { success: false, error: 'Chat identifier and title are required' }
+    }
+
+    const identifierPattern = /^[a-z0-9-]+$/
+    if (!identifierPattern.test(identifier)) {
+      return {
+        success: false,
+        error: 'Identifier can only contain lowercase letters, numbers, and hyphens',
+      }
+    }
+
+    const existingIdentifier = await db
+      .select()
+      .from(chat)
+      .where(and(eq(chat.identifier, identifier), isNull(chat.archivedAt)))
+      .limit(1)
+    if (existingIdentifier.length > 0 && existingIdentifier[0].id !== existingDeployment?.id) {
+      return { success: false, error: 'Identifier already in use' }
+    }
+
+    const existingCustomizations =
+      (existingDeployment?.customizations as
+        | { primaryColor?: string; welcomeMessage?: string; imageUrl?: string }
+        | undefined) || {}
+    const resolvedDescription = String(params.description || existingDeployment?.description || '')
+    const resolvedAuthType = (params.authType || existingDeployment?.authType || 'public') as
+      | 'public'
+      | 'password'
+      | 'email'
+      | 'sso'
+    const resolvedAllowedEmails =
+      params.allowedEmails || (existingDeployment?.allowedEmails as string[]) || []
+    const resolvedOutputConfigs = (params.outputConfigs ||
+      existingDeployment?.outputConfigs ||
+      []) as Array<{
+      blockId: string
+      path: string
+    }>
+    const welcomeMessage =
+      typeof params.welcomeMessage === 'string'
+        ? params.welcomeMessage
+        : params.customizations?.welcomeMessage || existingCustomizations.welcomeMessage
+    const imageUrl =
+      params.customizations?.imageUrl ||
+      params.customizations?.iconUrl ||
+      existingCustomizations.imageUrl
+
+    const result = await performChatDeploy({
+      workflowId,
+      userId: context.userId,
+      identifier,
+      title,
+      description: resolvedDescription,
+      customizations: {
+        primaryColor:
+          params.customizations?.primaryColor ||
+          existingCustomizations.primaryColor ||
+          'var(--brand-hover)',
+        welcomeMessage: welcomeMessage || 'Hi there! How can I help you today?',
+        ...(imageUrl ? { imageUrl } : {}),
+      },
+      authType: resolvedAuthType,
+      password: params.password,
+      allowedEmails: resolvedAllowedEmails,
+      outputConfigs: resolvedOutputConfigs,
+      workspaceId: workflowRecord.workspaceId,
+    })
+
+    if (!result.success) {
+      return { success: false, error: result.error || 'Failed to deploy chat' }
+    }
+
+    const baseUrl = getBaseUrl()
+    const apiEndpoint = buildWorkflowApiEndpoint(baseUrl, workflowId)
+    const apiConfig = buildWorkflowApiConfig(baseUrl, apiEndpoint)
+    const apiExamples = buildWorkflowApiExamples(baseUrl, apiEndpoint)
+    return {
+      success: true,
+      output: {
+        workflowId,
+        success: true,
+        action: 'deploy',
+        isDeployed: true,
+        isChatDeployed: true,
+        identifier,
+        chatUrl: result.chatUrl,
+        apiEndpoint,
+        baseUrl,
+        deployedAt: result.deployedAt || null,
+        version: result.version,
+        deploymentType: 'chat',
+        deploymentStatus: {
+          api: {
+            isDeployed: true,
+            endpoint: apiEndpoint,
+            deployedAt: result.deployedAt || null,
+            version: result.version,
+          },
+          chat: {
+            isDeployed: true,
+            identifier,
+            chatUrl: result.chatUrl,
+            title,
+            description: resolvedDescription,
+            authType: resolvedAuthType,
+          },
+        },
+        deploymentConfig: {
+          api: apiConfig,
+          chat: {
+            identifier,
+            chatUrl: result.chatUrl,
+            title,
+            description: resolvedDescription,
+            authType: resolvedAuthType,
+            allowedEmails: resolvedAllowedEmails,
+            outputConfigs: resolvedOutputConfigs,
+            welcomeMessage: welcomeMessage || 'Hi there! How can I help you today?',
+            primaryColor:
+              params.customizations?.primaryColor ||
+              existingCustomizations.primaryColor ||
+              'var(--brand-hover)',
+            ...(imageUrl ? { imageUrl } : {}),
+          },
+        },
+        examples: {
+          chat: {
+            open: result.chatUrl,
+          },
+          api: {
+            curl: apiExamples,
+          },
+        },
+      },
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export async function executeDeployMcp(
+  params: DeployMcpParams,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  try {
+    const workflowId = params.workflowId || context.workflowId
+    if (!workflowId) {
+      return { success: false, error: 'workflowId is required' }
+    }
+
+    const { workflow: workflowRecord } = await ensureWorkflowAccess(
+      workflowId,
+      context.userId,
+      'admin'
+    )
+    const workspaceId = workflowRecord.workspaceId
+    if (!workspaceId) {
+      return { success: false, error: 'workspaceId is required' }
+    }
+
+    const serverId = params.serverId
+    if (!serverId) {
+      return {
+        success: false,
+        error: 'serverId is required. Use list_workspace_mcp_servers to get available servers.',
+      }
+    }
+    const [serverRecord] = await db
+      .select({
+        id: workflowMcpServer.id,
+        name: workflowMcpServer.name,
+      })
+      .from(workflowMcpServer)
+      .where(
+        and(
+          eq(workflowMcpServer.id, serverId),
+          eq(workflowMcpServer.workspaceId, workspaceId),
+          isNull(workflowMcpServer.deletedAt)
+        )
+      )
+      .limit(1)
+    if (!serverRecord) {
+      return { success: false, error: 'MCP server not found in this workspace' }
+    }
+
+    // Handle undeploy action — remove workflow from MCP server
+    if (params.action === 'undeploy') {
+      const deleted = await db
+        .delete(workflowMcpTool)
+        .where(
+          and(eq(workflowMcpTool.serverId, serverId), eq(workflowMcpTool.workflowId, workflowId))
+        )
+        .returning({ id: workflowMcpTool.id })
+
+      if (deleted.length === 0) {
+        return { success: false, error: 'Workflow is not deployed to this MCP server' }
+      }
+
+      mcpPubSub?.publishWorkflowToolsChanged({ serverId, workspaceId })
+
+      recordAudit({
+        workspaceId,
+        actorId: context.userId,
+        action: AuditAction.MCP_SERVER_REMOVED,
+        resourceType: AuditResourceType.MCP_SERVER,
+        resourceId: serverId,
+        description: `Undeployed workflow "${workflowId}" from MCP server`,
+      })
+
+      return {
+        success: true,
+        output: {
+          workflowId,
+          serverId,
+          serverName: serverRecord.name,
+          action: 'undeploy',
+          removed: true,
+          deploymentType: 'mcp',
+          deploymentStatus: {
+            mcp: {
+              isDeployed: false,
+              serverId,
+              serverName: serverRecord.name,
+            },
+          },
+        },
+      }
+    }
+
+    if (!workflowRecord.isDeployed) {
+      return {
+        success: false,
+        error: 'Workflow must be deployed before adding as an MCP tool. Use deploy_api first.',
+      }
+    }
+
+    const existingTool = await db
+      .select()
+      .from(workflowMcpTool)
+      .where(
+        and(
+          eq(workflowMcpTool.serverId, serverId),
+          eq(workflowMcpTool.workflowId, workflowId),
+          isNull(workflowMcpTool.archivedAt)
+        )
+      )
+      .limit(1)
+
+    const toolName = sanitizeToolName(
+      params.toolName || workflowRecord.name || `workflow_${workflowId}`
+    )
+    const toolDescription =
+      params.toolDescription ||
+      workflowRecord.description ||
+      `Execute ${workflowRecord.name} workflow`
+    const parameterSchema =
+      params.parameterSchema && Object.keys(params.parameterSchema).length > 0
+        ? params.parameterSchema
+        : await generateParameterSchemaForWorkflow(workflowId)
+
+    const baseUrl = getBaseUrl()
+    const mcpServerUrl = `${baseUrl}/api/mcp/serve/${serverId}`
+    const apiEndpoint = buildWorkflowApiEndpoint(baseUrl, workflowId)
+    const clientExamples = buildMcpClientExamples(serverRecord.name, mcpServerUrl)
+
+    if (existingTool.length > 0) {
+      const toolId = existingTool[0].id
+      await db
+        .update(workflowMcpTool)
+        .set({
+          toolName,
+          toolDescription,
+          parameterSchema,
+          updatedAt: new Date(),
+        })
+        .where(eq(workflowMcpTool.id, toolId))
+
+      mcpPubSub?.publishWorkflowToolsChanged({ serverId, workspaceId })
+
+      recordAudit({
+        workspaceId,
+        actorId: context.userId,
+        action: AuditAction.MCP_SERVER_UPDATED,
+        resourceType: AuditResourceType.MCP_SERVER,
+        resourceId: serverId,
+        description: `Updated MCP tool "${toolName}" on server`,
+      })
+
+      return {
+        success: true,
+        output: {
+          toolId,
+          toolName,
+          toolDescription,
+          updated: true,
+          mcpServerUrl,
+          baseUrl,
+          serverId,
+          serverName: serverRecord.name,
+          deploymentType: 'mcp',
+          apiEndpoint,
+          deploymentStatus: {
+            api: {
+              isDeployed: true,
+              endpoint: apiEndpoint,
+            },
+            mcp: {
+              isDeployed: true,
+              serverId,
+              serverName: serverRecord.name,
+              toolId,
+              toolName,
+              updated: true,
+            },
+          },
+          deploymentConfig: {
+            mcp: {
+              serverId,
+              serverName: serverRecord.name,
+              serverUrl: mcpServerUrl,
+              toolId,
+              toolName,
+              toolDescription,
+              parameterSchema,
+              authentication: {
+                type: 'api_key',
+                header: 'X-API-Key: YOUR_API_KEY',
+              },
+            },
+          },
+          examples: {
+            mcp: clientExamples,
+          },
+        },
+      }
+    }
+
+    const toolId = generateId()
+    await db.insert(workflowMcpTool).values({
+      id: toolId,
+      serverId,
+      workflowId,
+      toolName,
+      toolDescription,
+      parameterSchema,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    })
+
+    mcpPubSub?.publishWorkflowToolsChanged({ serverId, workspaceId })
+
+    recordAudit({
+      workspaceId,
+      actorId: context.userId,
+      action: AuditAction.MCP_SERVER_ADDED,
+      resourceType: AuditResourceType.MCP_SERVER,
+      resourceId: serverId,
+      description: `Deployed workflow as MCP tool "${toolName}"`,
+    })
+
+    return {
+      success: true,
+      output: {
+        toolId,
+        toolName,
+        toolDescription,
+        updated: false,
+        mcpServerUrl,
+        baseUrl,
+        serverId,
+        serverName: serverRecord.name,
+        deploymentType: 'mcp',
+        apiEndpoint,
+        deploymentStatus: {
+          api: {
+            isDeployed: true,
+            endpoint: apiEndpoint,
+          },
+          mcp: {
+            isDeployed: true,
+            serverId,
+            serverName: serverRecord.name,
+            toolId,
+            toolName,
+            updated: false,
+          },
+        },
+        deploymentConfig: {
+          mcp: {
+            serverId,
+            serverName: serverRecord.name,
+            serverUrl: mcpServerUrl,
+            toolId,
+            toolName,
+            toolDescription,
+            parameterSchema,
+            authentication: {
+              type: 'api_key',
+              header: 'X-API-Key: YOUR_API_KEY',
+            },
+          },
+        },
+        examples: {
+          mcp: clientExamples,
+        },
+      },
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export async function executeRedeploy(
+  params: { workflowId?: string },
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  try {
+    const workflowId = params.workflowId || context.workflowId
+    if (!workflowId) {
+      return { success: false, error: 'workflowId is required' }
+    }
+    await ensureWorkflowAccess(workflowId, context.userId, 'admin')
+
+    const result = await performFullDeploy({ workflowId, userId: context.userId })
+    if (!result.success) {
+      return { success: false, error: result.error || 'Failed to redeploy workflow' }
+    }
+    const baseUrl = getBaseUrl()
+    const apiEndpoint = buildWorkflowApiEndpoint(baseUrl, workflowId)
+    const apiConfig = buildWorkflowApiConfig(baseUrl, apiEndpoint)
+    const apiExamples = buildWorkflowApiExamples(baseUrl, apiEndpoint)
+    return {
+      success: true,
+      output: {
+        workflowId,
+        isDeployed: true,
+        deployedAt: result.deployedAt || null,
+        version: result.version,
+        apiEndpoint,
+        baseUrl,
+        deploymentType: 'api',
+        deploymentStatus: {
+          api: {
+            isDeployed: true,
+            endpoint: apiEndpoint,
+            deployedAt: result.deployedAt || null,
+            version: result.version,
+          },
+        },
+        deploymentConfig: {
+          api: apiConfig,
+        },
+        examples: {
+          api: {
+            curl: apiExamples,
+          },
+        },
+      },
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/manage.ts b/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
similarity index 99%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/manage.ts
rename to apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
index 00ecfce4dce..211646139a7 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/deployment-tools/manage.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
@@ -8,7 +8,7 @@ import {
 } from '@sim/db/schema'
 import { and, eq, inArray, isNull } from 'drizzle-orm'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { generateId } from '@/lib/core/utils/uuid'
 import { mcpPubSub } from '@/lib/mcp/pubsub'
 import { generateParameterSchemaForWorkflow } from '@/lib/mcp/workflow-mcp-sync'
diff --git a/apps/sim/lib/copilot/tools/handlers/function-execute.ts b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
new file mode 100644
index 00000000000..61cf5ed6219
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
@@ -0,0 +1,147 @@
+import { createLogger } from '@sim/logger'
+import { getTableById, queryRows } from '@/lib/table/service'
+import {
+  downloadWorkspaceFile,
+  findWorkspaceFileRecord,
+  getSandboxWorkspaceFilePath,
+  listWorkspaceFiles,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { executeTool as executeAppTool } from '@/tools'
+import type { ToolExecutionContext, ToolExecutionResult } from '../../tool-executor/types'
+
+const logger = createLogger('CopilotFunctionExecute')
+
+const MAX_FILE_SIZE = 10 * 1024 * 1024
+const MAX_TOTAL_SIZE = 50 * 1024 * 1024
+
+interface SandboxFile {
+  path: string
+  content: string
+}
+
+async function resolveInputFiles(
+  workspaceId: string,
+  inputFiles?: unknown[],
+  inputTables?: unknown[]
+): Promise<SandboxFile[]> {
+  const sandboxFiles: SandboxFile[] = []
+  let totalSize = 0
+
+  if (inputFiles?.length && workspaceId) {
+    const allFiles = await listWorkspaceFiles(workspaceId)
+    for (const fileRef of inputFiles) {
+      if (typeof fileRef !== 'string') continue
+      const record = findWorkspaceFileRecord(allFiles, fileRef)
+      if (!record) {
+        logger.warn('Input file not found', { fileRef })
+        continue
+      }
+      if (record.size > MAX_FILE_SIZE) {
+        logger.warn('Input file exceeds size limit', { fileId: record.id, size: record.size })
+        continue
+      }
+      if (totalSize + record.size > MAX_TOTAL_SIZE) {
+        logger.warn('Total input size limit reached')
+        break
+      }
+      const buffer = await downloadWorkspaceFile(record)
+      totalSize += buffer.length
+      const isText = /^text\/|application\/json|application\/xml|application\/csv/.test(
+        record.type || ''
+      )
+      const content = isText ? buffer.toString('utf-8') : buffer.toString('base64')
+      sandboxFiles.push({
+        path: getSandboxWorkspaceFilePath(record),
+        content,
+        encoding: isText ? undefined : 'base64',
+      } as SandboxFile)
+    }
+  }
+
+  if (inputTables?.length) {
+    for (const tableId of inputTables) {
+      if (typeof tableId !== 'string') continue
+      const table = await getTableById(tableId)
+      if (!table) {
+        logger.warn('Input table not found', { tableId })
+        continue
+      }
+      const rows = await queryRows(tableId, workspaceId, {}, 'copilot-fn-exec')
+      if (!rows.rows?.length) continue
+
+      const allKeys = new Set<string>()
+      for (const row of rows.rows) {
+        if (row.data && typeof row.data === 'object') {
+          for (const key of Object.keys(row.data as Record<string, unknown>)) {
+            allKeys.add(key)
+          }
+        }
+      }
+      const headers = Array.from(allKeys)
+      const csvLines = [headers.join(',')]
+      for (const row of rows.rows) {
+        const data = (row.data || {}) as Record<string, unknown>
+        csvLines.push(
+          headers
+            .map((h) => {
+              const val = data[h]
+              const str = val === null || val === undefined ? '' : String(val)
+              return str.includes(',') || str.includes('"') || str.includes('\n')
+                ? `"${str.replace(/"/g, '""')}"`
+                : str
+            })
+            .join(',')
+        )
+      }
+      const csvContent = csvLines.join('\n')
+      sandboxFiles.push({
+        path: `/home/user/tables/${tableId}.csv`,
+        content: csvContent,
+      })
+    }
+  }
+
+  return sandboxFiles
+}
+
+export async function executeFunctionExecute(
+  params: Record<string, unknown>,
+  context: ToolExecutionContext
+): Promise<ToolExecutionResult> {
+  const enrichedParams = { ...params }
+
+  if (context.decryptedEnvVars && Object.keys(context.decryptedEnvVars).length > 0) {
+    enrichedParams.envVars = {
+      ...context.decryptedEnvVars,
+      ...((enrichedParams.envVars as Record<string, string>) || {}),
+    }
+  }
+
+  if (context.workspaceId) {
+    const inputFiles = enrichedParams.inputFiles as unknown[] | undefined
+    const inputTables = enrichedParams.inputTables as unknown[] | undefined
+
+    if (inputFiles?.length || inputTables?.length) {
+      const resolved = await resolveInputFiles(context.workspaceId, inputFiles, inputTables)
+      if (resolved.length > 0) {
+        const existing = (enrichedParams._sandboxFiles as SandboxFile[]) || []
+        enrichedParams._sandboxFiles = [...existing, ...resolved]
+      }
+    }
+  }
+
+  enrichedParams._context = {
+    ...(typeof enrichedParams._context === 'object' && enrichedParams._context !== null
+      ? (enrichedParams._context as object)
+      : {}),
+    userId: context.userId,
+    workflowId: context.workflowId,
+    workspaceId: context.workspaceId,
+    chatId: context.chatId,
+    executionId: context.executionId,
+    runId: context.runId,
+    enforceCredentialAccess: true,
+  }
+
+  return executeAppTool('function_execute', enrichedParams, false)
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/job-tools.ts b/apps/sim/lib/copilot/tools/handlers/jobs.ts
similarity index 93%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/job-tools.ts
rename to apps/sim/lib/copilot/tools/handlers/jobs.ts
index 00d18a6188d..f271e19ddea 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/job-tools.ts
+++ b/apps/sim/lib/copilot/tools/handlers/jobs.ts
@@ -3,7 +3,7 @@ import { copilotChats, workflowSchedule } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, isNull } from 'drizzle-orm'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { generateId } from '@/lib/core/utils/uuid'
 import { parseCronToHumanReadable, validateCronExpression } from '@/lib/workflows/schedules/utils'
 
@@ -184,6 +184,7 @@ interface ManageJobParams {
   operation: 'create' | 'list' | 'get' | 'update' | 'delete'
   args?: {
     jobId?: string
+    jobIds?: string[]
     title?: string
     prompt?: string
     cron?: string
@@ -423,43 +424,46 @@ export async function executeManageJob(
     }
 
     case 'delete': {
-      if (!args?.jobId) {
-        return { success: false, error: 'jobId is required for delete operation' }
+      const jobIds = args?.jobIds ?? (args?.jobId ? [args.jobId] : [])
+      if (jobIds.length === 0) {
+        return { success: false, error: 'jobId or jobIds is required for delete operation' }
       }
 
       try {
-        const [existing] = await db
-          .select({ id: workflowSchedule.id })
-          .from(workflowSchedule)
-          .where(
-            and(eq(workflowSchedule.id, args.jobId), ACTIVE_JOB_CONDITION(context.workspaceId))
-          )
-          .limit(1)
-
-        if (!existing) {
-          return { success: false, error: `Job not found: ${args.jobId}` }
-        }
+        const deleted: string[] = []
+        const notFound: string[] = []
+
+        for (const jobId of jobIds) {
+          const [existing] = await db
+            .select({ id: workflowSchedule.id })
+            .from(workflowSchedule)
+            .where(and(eq(workflowSchedule.id, jobId), ACTIVE_JOB_CONDITION(context.workspaceId)))
+            .limit(1)
+
+          if (!existing) {
+            notFound.push(jobId)
+            continue
+          }
 
-        await db.delete(workflowSchedule).where(eq(workflowSchedule.id, args.jobId))
+          await db.delete(workflowSchedule).where(eq(workflowSchedule.id, jobId))
+          deleted.push(jobId)
 
-        logger.info('Job deleted', { jobId: args.jobId })
+          logger.info('Job deleted', { jobId })
 
-        recordAudit({
-          workspaceId: context.workspaceId || null,
-          actorId: context.userId,
-          action: AuditAction.SCHEDULE_UPDATED,
-          resourceType: AuditResourceType.SCHEDULE,
-          resourceId: args.jobId,
-          description: `Deleted job`,
-          metadata: { operation: 'delete' },
-        })
+          recordAudit({
+            workspaceId: context.workspaceId || null,
+            actorId: context.userId,
+            action: AuditAction.SCHEDULE_UPDATED,
+            resourceType: AuditResourceType.SCHEDULE,
+            resourceId: jobId,
+            description: `Deleted job`,
+            metadata: { operation: 'delete' },
+          })
+        }
 
         return {
-          success: true,
-          output: {
-            jobId: args.jobId,
-            message: 'Job deleted successfully',
-          },
+          success: deleted.length > 0,
+          output: { deleted, notFound },
         }
       } catch (err) {
         logger.error('Failed to delete job', {
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-credential.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-credential.ts
new file mode 100644
index 00000000000..da775526d4f
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-credential.ts
@@ -0,0 +1,83 @@
+import { db } from '@sim/db'
+import { credential } from '@sim/db/schema'
+import { eq } from 'drizzle-orm'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+
+export function executeManageCredential(
+  rawParams: Record<string, unknown>,
+  _context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as {
+    operation: string
+    credentialId?: string
+    credentialIds?: string[]
+    displayName?: string
+  }
+  const { operation, displayName } = params
+  return (async () => {
+    try {
+      switch (operation) {
+        case 'rename': {
+          const credentialId = params.credentialId
+          if (!credentialId) return { success: false, error: 'credentialId is required for rename' }
+          if (!displayName) return { success: false, error: 'displayName is required for rename' }
+          const [row] = await db
+            .select({
+              id: credential.id,
+              type: credential.type,
+              displayName: credential.displayName,
+            })
+            .from(credential)
+            .where(eq(credential.id, credentialId))
+            .limit(1)
+          if (!row) return { success: false, error: 'Credential not found' }
+          if (row.type !== 'oauth')
+            return {
+              success: false,
+              error: 'Only OAuth credentials can be managed with this tool.',
+            }
+          await db
+            .update(credential)
+            .set({ displayName, updatedAt: new Date() })
+            .where(eq(credential.id, credentialId))
+          return { success: true, output: { credentialId, displayName } }
+        }
+        case 'delete': {
+          const ids: string[] =
+            params.credentialIds ?? (params.credentialId ? [params.credentialId] : [])
+          if (ids.length === 0)
+            return { success: false, error: 'credentialId or credentialIds is required for delete' }
+
+          const deleted: string[] = []
+          const failed: string[] = []
+
+          for (const id of ids) {
+            const [row] = await db
+              .select({ id: credential.id, type: credential.type })
+              .from(credential)
+              .where(eq(credential.id, id))
+              .limit(1)
+            if (!row || row.type !== 'oauth') {
+              failed.push(id)
+              continue
+            }
+            await db.delete(credential).where(eq(credential.id, id))
+            deleted.push(id)
+          }
+
+          return {
+            success: deleted.length > 0,
+            output: { deleted, failed },
+          }
+        }
+        default:
+          return {
+            success: false,
+            error: `Unknown operation: ${operation}. Use "rename" or "delete".`,
+          }
+      }
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) }
+    }
+  })()
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts
new file mode 100644
index 00000000000..b67eb3cf146
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts
@@ -0,0 +1,217 @@
+import { createLogger } from '@sim/logger'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import {
+  deleteCustomTool,
+  getCustomToolById,
+  listCustomTools,
+  upsertCustomTools,
+} from '@/lib/workflows/custom-tools/operations'
+
+const logger = createLogger('CopilotToolExecutor')
+
+type ManageCustomToolOperation = 'add' | 'edit' | 'delete' | 'list'
+
+interface ManageCustomToolSchema {
+  type: 'function'
+  function: {
+    name: string
+    description?: string
+    parameters: Record<string, unknown>
+  }
+}
+
+interface ManageCustomToolParams {
+  operation?: string
+  toolId?: string
+  toolIds?: string[]
+  schema?: ManageCustomToolSchema
+  code?: string
+  title?: string
+  workspaceId?: string
+}
+
+export async function executeManageCustomTool(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as ManageCustomToolParams
+  const operation = String(params.operation || '').toLowerCase() as ManageCustomToolOperation
+  const workspaceId = params.workspaceId || context.workspaceId
+
+  if (!operation) {
+    return { success: false, error: "Missing required 'operation' argument" }
+  }
+
+  const writeOps: string[] = ['add', 'edit', 'delete']
+  if (
+    writeOps.includes(operation) &&
+    context.userPermission &&
+    context.userPermission !== 'write' &&
+    context.userPermission !== 'admin'
+  ) {
+    return {
+      success: false,
+      error: `Permission denied: '${operation}' on manage_custom_tool requires write access. You have '${context.userPermission}' permission.`,
+    }
+  }
+
+  try {
+    if (operation === 'list') {
+      const toolsForUser = await listCustomTools({
+        userId: context.userId,
+        workspaceId,
+      })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          tools: toolsForUser,
+          count: toolsForUser.length,
+        },
+      }
+    }
+
+    if (operation === 'add') {
+      if (!workspaceId) {
+        return {
+          success: false,
+          error: "workspaceId is required for operation 'add'",
+        }
+      }
+      if (!params.schema || !params.code) {
+        return {
+          success: false,
+          error: "Both 'schema' and 'code' are required for operation 'add'",
+        }
+      }
+
+      const title = params.title || params.schema.function?.name
+      if (!title) {
+        return { success: false, error: "Missing tool title or schema.function.name for 'add'" }
+      }
+
+      const resultTools = await upsertCustomTools({
+        tools: [{ title, schema: params.schema, code: params.code }],
+        workspaceId,
+        userId: context.userId,
+      })
+      const created = resultTools.find((tool) => tool.title === title)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          toolId: created?.id,
+          title,
+          message: `Created custom tool "${title}"`,
+        },
+      }
+    }
+
+    if (operation === 'edit') {
+      if (!workspaceId) {
+        return {
+          success: false,
+          error: "workspaceId is required for operation 'edit'",
+        }
+      }
+      if (!params.toolId) {
+        return { success: false, error: "'toolId' is required for operation 'edit'" }
+      }
+      if (!params.schema && !params.code) {
+        return {
+          success: false,
+          error: "At least one of 'schema' or 'code' is required for operation 'edit'",
+        }
+      }
+
+      const existing = await getCustomToolById({
+        toolId: params.toolId,
+        userId: context.userId,
+        workspaceId,
+      })
+      if (!existing) {
+        return { success: false, error: `Custom tool not found: ${params.toolId}` }
+      }
+
+      const mergedSchema = params.schema || (existing.schema as ManageCustomToolSchema)
+      const mergedCode = params.code || existing.code
+      const title = params.title || mergedSchema.function?.name || existing.title
+
+      await upsertCustomTools({
+        tools: [{ id: params.toolId, title, schema: mergedSchema, code: mergedCode }],
+        workspaceId,
+        userId: context.userId,
+      })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          toolId: params.toolId,
+          title,
+          message: `Updated custom tool "${title}"`,
+        },
+      }
+    }
+
+    if (operation === 'delete') {
+      const toolIds: string[] = params.toolIds ?? (params.toolId ? [params.toolId] : [])
+      if (toolIds.length === 0) {
+        return { success: false, error: "'toolId' or 'toolIds' is required for operation 'delete'" }
+      }
+
+      const deleted: string[] = []
+      const notFound: string[] = []
+
+      for (const toolId of toolIds) {
+        const result = await deleteCustomTool({
+          toolId,
+          userId: context.userId,
+          workspaceId,
+        })
+        if (result) {
+          deleted.push(toolId)
+        } else {
+          notFound.push(toolId)
+        }
+      }
+
+      return {
+        success: deleted.length > 0,
+        output: {
+          success: deleted.length > 0,
+          operation,
+          deleted,
+          notFound,
+          message: `Deleted ${deleted.length} custom tool(s)`,
+        },
+      }
+    }
+
+    return {
+      success: false,
+      error: `Unsupported operation for manage_custom_tool: ${operation}`,
+    }
+  } catch (error) {
+    logger.error(
+      context.messageId
+        ? `manage_custom_tool execution failed [messageId:${context.messageId}]`
+        : 'manage_custom_tool execution failed',
+      {
+        operation,
+        workspaceId,
+        userId: context.userId,
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to manage custom tool',
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts
new file mode 100644
index 00000000000..be7b327bdbc
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts
@@ -0,0 +1,246 @@
+import { db } from '@sim/db'
+import { mcpServers } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, isNull } from 'drizzle-orm'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { validateMcpDomain } from '@/lib/mcp/domain-check'
+import { mcpService } from '@/lib/mcp/service'
+import { generateMcpServerId } from '@/lib/mcp/utils'
+
+const logger = createLogger('CopilotToolExecutor')
+
+type ManageMcpToolOperation = 'add' | 'edit' | 'delete' | 'list'
+
+interface ManageMcpToolConfig {
+  name?: string
+  transport?: string
+  url?: string
+  headers?: Record<string, string>
+  timeout?: number
+  enabled?: boolean
+}
+
+interface ManageMcpToolParams {
+  operation?: string
+  serverId?: string
+  config?: ManageMcpToolConfig
+}
+
+export async function executeManageMcpTool(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as ManageMcpToolParams
+  const operation = String(params.operation || '').toLowerCase() as ManageMcpToolOperation
+  const workspaceId = context.workspaceId
+
+  if (!operation) {
+    return { success: false, error: "Missing required 'operation' argument" }
+  }
+
+  if (!workspaceId) {
+    return { success: false, error: 'workspaceId is required' }
+  }
+
+  const writeOps: string[] = ['add', 'edit', 'delete']
+  if (
+    writeOps.includes(operation) &&
+    context.userPermission &&
+    context.userPermission !== 'write' &&
+    context.userPermission !== 'admin'
+  ) {
+    return {
+      success: false,
+      error: `Permission denied: '${operation}' on manage_mcp_tool requires write access. You have '${context.userPermission}' permission.`,
+    }
+  }
+
+  try {
+    if (operation === 'list') {
+      const servers = await db
+        .select()
+        .from(mcpServers)
+        .where(and(eq(mcpServers.workspaceId, workspaceId), isNull(mcpServers.deletedAt)))
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          servers: servers.map((s) => ({
+            id: s.id,
+            name: s.name,
+            url: s.url,
+            transport: s.transport,
+            enabled: s.enabled,
+            connectionStatus: s.connectionStatus,
+          })),
+          count: servers.length,
+        },
+      }
+    }
+
+    if (operation === 'add') {
+      const config = params.config
+      if (!config?.name || !config?.url) {
+        return { success: false, error: "config.name and config.url are required for 'add'" }
+      }
+
+      validateMcpDomain(config.url)
+
+      const serverId = generateMcpServerId(workspaceId, config.url)
+
+      const [existing] = await db
+        .select({ id: mcpServers.id, deletedAt: mcpServers.deletedAt })
+        .from(mcpServers)
+        .where(and(eq(mcpServers.id, serverId), eq(mcpServers.workspaceId, workspaceId)))
+        .limit(1)
+
+      if (existing) {
+        await db
+          .update(mcpServers)
+          .set({
+            name: config.name,
+            transport: config.transport || 'streamable-http',
+            url: config.url,
+            headers: config.headers || {},
+            timeout: config.timeout || 30000,
+            enabled: config.enabled !== false,
+            connectionStatus: 'connected',
+            lastConnected: new Date(),
+            updatedAt: new Date(),
+            deletedAt: null,
+          })
+          .where(eq(mcpServers.id, serverId))
+      } else {
+        await db.insert(mcpServers).values({
+          id: serverId,
+          workspaceId,
+          createdBy: context.userId,
+          name: config.name,
+          description: '',
+          transport: config.transport || 'streamable-http',
+          url: config.url,
+          headers: config.headers || {},
+          timeout: config.timeout || 30000,
+          retries: 3,
+          enabled: config.enabled !== false,
+          connectionStatus: 'connected',
+          lastConnected: new Date(),
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        })
+      }
+
+      await mcpService.clearCache(workspaceId)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          serverId,
+          name: config.name,
+          message: existing
+            ? `Updated existing MCP server "${config.name}"`
+            : `Added MCP server "${config.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'edit') {
+      if (!params.serverId) {
+        return { success: false, error: "'serverId' is required for 'edit'" }
+      }
+      const config = params.config
+      if (!config) {
+        return { success: false, error: "'config' is required for 'edit'" }
+      }
+
+      if (config.url) {
+        validateMcpDomain(config.url)
+      }
+
+      const updateData: Record<string, unknown> = { updatedAt: new Date() }
+      if (config.name !== undefined) updateData.name = config.name
+      if (config.transport !== undefined) updateData.transport = config.transport
+      if (config.url !== undefined) updateData.url = config.url
+      if (config.headers !== undefined) updateData.headers = config.headers
+      if (config.timeout !== undefined) updateData.timeout = config.timeout
+      if (config.enabled !== undefined) updateData.enabled = config.enabled
+
+      const [updated] = await db
+        .update(mcpServers)
+        .set(updateData)
+        .where(
+          and(
+            eq(mcpServers.id, params.serverId),
+            eq(mcpServers.workspaceId, workspaceId),
+            isNull(mcpServers.deletedAt)
+          )
+        )
+        .returning()
+
+      if (!updated) {
+        return { success: false, error: `MCP server not found: ${params.serverId}` }
+      }
+
+      await mcpService.clearCache(workspaceId)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          serverId: params.serverId,
+          name: updated.name,
+          message: `Updated MCP server "${updated.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'delete') {
+      if (!params.serverId) {
+        return { success: false, error: "'serverId' is required for 'delete'" }
+      }
+
+      const [deleted] = await db
+        .delete(mcpServers)
+        .where(and(eq(mcpServers.id, params.serverId), eq(mcpServers.workspaceId, workspaceId)))
+        .returning()
+
+      if (!deleted) {
+        return { success: false, error: `MCP server not found: ${params.serverId}` }
+      }
+
+      await mcpService.clearCache(workspaceId)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          serverId: params.serverId,
+          message: `Deleted MCP server "${deleted.name}"`,
+        },
+      }
+    }
+
+    return { success: false, error: `Unsupported operation for manage_mcp_tool: ${operation}` }
+  } catch (error) {
+    logger.error(
+      context.messageId
+        ? `manage_mcp_tool execution failed [messageId:${context.messageId}]`
+        : 'manage_mcp_tool execution failed',
+      {
+        operation,
+        workspaceId,
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to manage MCP server',
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-skill.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-skill.ts
new file mode 100644
index 00000000000..a1e5ed7de9e
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-skill.ts
@@ -0,0 +1,173 @@
+import { createLogger } from '@sim/logger'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { deleteSkill, listSkills, upsertSkills } from '@/lib/workflows/skills/operations'
+
+const logger = createLogger('CopilotToolExecutor')
+
+type ManageSkillOperation = 'add' | 'edit' | 'delete' | 'list'
+
+interface ManageSkillParams {
+  operation?: string
+  skillId?: string
+  name?: string
+  description?: string
+  content?: string
+}
+
+export async function executeManageSkill(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as ManageSkillParams
+  const operation = String(params.operation || '').toLowerCase() as ManageSkillOperation
+  const workspaceId = context.workspaceId
+
+  if (!operation) {
+    return { success: false, error: "Missing required 'operation' argument" }
+  }
+
+  if (!workspaceId) {
+    return { success: false, error: 'workspaceId is required' }
+  }
+
+  const writeOps: string[] = ['add', 'edit', 'delete']
+  if (
+    writeOps.includes(operation) &&
+    context.userPermission &&
+    context.userPermission !== 'write' &&
+    context.userPermission !== 'admin'
+  ) {
+    return {
+      success: false,
+      error: `Permission denied: '${operation}' on manage_skill requires write access. You have '${context.userPermission}' permission.`,
+    }
+  }
+
+  try {
+    if (operation === 'list') {
+      const skills = await listSkills({ workspaceId })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skills: skills.map((s) => ({
+            id: s.id,
+            name: s.name,
+            description: s.description,
+            createdAt: s.createdAt,
+          })),
+          count: skills.length,
+        },
+      }
+    }
+
+    if (operation === 'add') {
+      if (!params.name || !params.description || !params.content) {
+        return {
+          success: false,
+          error: "'name', 'description', and 'content' are required for 'add'",
+        }
+      }
+
+      const resultSkills = await upsertSkills({
+        skills: [{ name: params.name, description: params.description, content: params.content }],
+        workspaceId,
+        userId: context.userId,
+      })
+      const created = resultSkills.find((s) => s.name === params.name)
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skillId: created?.id,
+          name: params.name,
+          message: `Created skill "${params.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'edit') {
+      if (!params.skillId) {
+        return { success: false, error: "'skillId' is required for 'edit'" }
+      }
+      if (!params.name && !params.description && !params.content) {
+        return {
+          success: false,
+          error: "At least one of 'name', 'description', or 'content' is required for 'edit'",
+        }
+      }
+
+      const existing = await listSkills({ workspaceId })
+      const found = existing.find((s) => s.id === params.skillId)
+      if (!found) {
+        return { success: false, error: `Skill not found: ${params.skillId}` }
+      }
+
+      await upsertSkills({
+        skills: [
+          {
+            id: params.skillId,
+            name: params.name || found.name,
+            description: params.description || found.description,
+            content: params.content || found.content,
+          },
+        ],
+        workspaceId,
+        userId: context.userId,
+      })
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skillId: params.skillId,
+          name: params.name || found.name,
+          message: `Updated skill "${params.name || found.name}"`,
+        },
+      }
+    }
+
+    if (operation === 'delete') {
+      if (!params.skillId) {
+        return { success: false, error: "'skillId' is required for 'delete'" }
+      }
+
+      const deleted = await deleteSkill({ skillId: params.skillId, workspaceId })
+      if (!deleted) {
+        return { success: false, error: `Skill not found: ${params.skillId}` }
+      }
+
+      return {
+        success: true,
+        output: {
+          success: true,
+          operation,
+          skillId: params.skillId,
+          message: 'Deleted skill',
+        },
+      }
+    }
+
+    return { success: false, error: `Unsupported operation for manage_skill: ${operation}` }
+  } catch (error) {
+    logger.error(
+      context.messageId
+        ? `manage_skill execution failed [messageId:${context.messageId}]`
+        : 'manage_skill execution failed',
+      {
+        operation,
+        workspaceId,
+        error: error instanceof Error ? error.message : String(error),
+      }
+    )
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to manage skill',
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/materialize-file.ts b/apps/sim/lib/copilot/tools/handlers/materialize-file.ts
similarity index 83%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/materialize-file.ts
rename to apps/sim/lib/copilot/tools/handlers/materialize-file.ts
index 6b2542394b9..0f59a81a6fa 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/materialize-file.ts
+++ b/apps/sim/lib/copilot/tools/handlers/materialize-file.ts
@@ -3,8 +3,8 @@ import { workflow, workspaceFiles } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, isNull } from 'drizzle-orm'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import { findMothershipUploadRowByChatAndName } from '@/lib/copilot/orchestrator/tool-executor/upload-file-reader'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { findMothershipUploadRowByChatAndName } from '@/lib/copilot/tools/handlers/upload-file-reader'
 import { generateId } from '@/lib/core/utils/uuid'
 import { getServePathPrefix } from '@/lib/uploads'
 import { downloadWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
@@ -186,9 +186,12 @@ export async function executeMaterializeFile(
   params: Record<string, unknown>,
   context: ExecutionContext
 ): Promise<ToolCallResult> {
-  const fileName = params.fileName as string | undefined
-  if (!fileName) {
-    return { success: false, error: "Missing required parameter 'fileName'" }
+  const fileNames: string[] =
+    (params.fileNames as string[] | undefined) ??
+    ([params.fileName as string | undefined].filter(Boolean) as string[])
+
+  if (fileNames.length === 0) {
+    return { success: false, error: "Missing required parameter 'fileNames'" }
   }
 
   if (!context.chatId) {
@@ -200,22 +203,37 @@ export async function executeMaterializeFile(
   }
 
   const operation = (params.operation as string | undefined) || 'save'
-
-  try {
-    if (operation === 'import') {
-      return await executeImport(fileName, context.chatId, context.workspaceId, context.userId)
-    }
-    return await executeSave(fileName, context.chatId)
-  } catch (err) {
-    logger.error('materialize_file failed', {
-      fileName,
-      operation,
-      chatId: context.chatId,
-      error: err instanceof Error ? err.message : String(err),
-    })
-    return {
-      success: false,
-      error: err instanceof Error ? err.message : 'Failed to materialize file',
+  const succeeded: string[] = []
+  const failed: Array<{ fileName: string; error: string }> = []
+
+  for (const fileName of fileNames) {
+    try {
+      if (operation === 'import') {
+        await executeImport(fileName, context.chatId, context.workspaceId, context.userId)
+      } else {
+        await executeSave(fileName, context.chatId)
+      }
+      succeeded.push(fileName)
+    } catch (err) {
+      logger.error('materialize_file failed', {
+        fileName,
+        operation,
+        chatId: context.chatId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+      failed.push({
+        fileName,
+        error: err instanceof Error ? err.message : 'Failed to materialize file',
+      })
     }
   }
+
+  return {
+    success: succeeded.length > 0,
+    output: { succeeded, failed },
+    error:
+      failed.length > 0
+        ? `Failed to materialize: ${failed.map((f) => f.fileName).join(', ')}`
+        : undefined,
+  }
 }
diff --git a/apps/sim/lib/copilot/tools/handlers/oauth.ts b/apps/sim/lib/copilot/tools/handlers/oauth.ts
new file mode 100644
index 00000000000..7ece3645fce
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/oauth.ts
@@ -0,0 +1,177 @@
+import { db } from '@sim/db'
+import { pendingCredentialDraft, user } from '@sim/db/schema'
+import { and, eq, lt } from 'drizzle-orm'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { getBaseUrl } from '@/lib/core/utils/urls'
+import { getAllOAuthServices } from '@/lib/oauth/utils'
+
+export async function executeOAuthGetAuthLink(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const providerName = String(rawParams.providerName || rawParams.provider_name || '')
+  const baseUrl = getBaseUrl()
+  try {
+    const result = await generateOAuthLink(
+      context.userId,
+      context.workspaceId,
+      context.workflowId,
+      context.chatId,
+      providerName,
+      baseUrl
+    )
+    return {
+      success: true,
+      output: {
+        message: `Authorization URL generated for ${result.serviceName}.`,
+        oauth_url: result.url,
+        instructions: `Open this URL in your browser to connect ${result.serviceName}: ${result.url}`,
+        provider: result.serviceName,
+        providerId: result.providerId,
+      },
+    }
+  } catch (err) {
+    const workspaceUrl = context.workspaceId
+      ? `${baseUrl}/workspace/${context.workspaceId}`
+      : `${baseUrl}/workspace`
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      output: {
+        message: `Could not generate a direct OAuth link for ${providerName}. Connect manually from the workspace.`,
+        oauth_url: workspaceUrl,
+        error: err instanceof Error ? err.message : String(err),
+      },
+    }
+  }
+}
+
+export async function executeOAuthRequestAccess(
+  rawParams: Record<string, unknown>,
+  _context: ExecutionContext
+): Promise<ToolCallResult> {
+  const providerName = String(rawParams.providerName || rawParams.provider_name || 'the provider')
+  return {
+    success: true,
+    output: {
+      status: 'requested',
+      providerName,
+      message: `Requested ${providerName} OAuth connection.`,
+    },
+  }
+}
+
+/**
+ * Resolves a human-friendly provider name to a providerId and generates the
+ * actual OAuth authorization URL via Better Auth's server-side API.
+ *
+ * Steps: resolve provider → create credential draft → look up user session →
+ * call auth.api.oAuth2LinkAccount → return the real authorization URL.
+ */
+export async function generateOAuthLink(
+  userId: string,
+  workspaceId: string | undefined,
+  workflowId: string | undefined,
+  chatId: string | undefined,
+  providerName: string,
+  baseUrl: string
+): Promise<{ url: string; providerId: string; serviceName: string }> {
+  if (!workspaceId) {
+    throw new Error('workspaceId is required to generate an OAuth link')
+  }
+
+  const allServices = getAllOAuthServices()
+  const normalizedInput = providerName.toLowerCase().trim()
+
+  const matched =
+    allServices.find((s) => s.providerId === normalizedInput) ||
+    allServices.find((s) => s.name.toLowerCase() === normalizedInput) ||
+    allServices.find(
+      (s) =>
+        s.name.toLowerCase().includes(normalizedInput) ||
+        normalizedInput.includes(s.name.toLowerCase())
+    ) ||
+    allServices.find(
+      (s) => s.providerId.includes(normalizedInput) || normalizedInput.includes(s.providerId)
+    )
+
+  if (!matched) {
+    const available = allServices.map((s) => s.name).join(', ')
+    throw new Error(`Provider "${providerName}" not found. Available providers: ${available}`)
+  }
+
+  const { providerId, name: serviceName } = matched
+  const callbackURL =
+    workflowId && workspaceId
+      ? `${baseUrl}/workspace/${workspaceId}/w/${workflowId}`
+      : chatId && workspaceId
+        ? `${baseUrl}/workspace/${workspaceId}/task/${chatId}`
+        : `${baseUrl}/workspace/${workspaceId}`
+
+  if (providerId === 'trello') {
+    return { url: `${baseUrl}/api/auth/trello/authorize`, providerId, serviceName }
+  }
+  if (providerId === 'shopify') {
+    const returnUrl = encodeURIComponent(callbackURL)
+    return {
+      url: `${baseUrl}/api/auth/shopify/authorize?returnUrl=${returnUrl}`,
+      providerId,
+      serviceName,
+    }
+  }
+
+  let displayName = serviceName
+  try {
+    const [row] = await db.select({ name: user.name }).from(user).where(eq(user.id, userId))
+    if (row?.name) {
+      displayName = `${row.name}'s ${serviceName}`
+    }
+  } catch {
+    // Fall back to service name only
+  }
+
+  const now = new Date()
+  await db
+    .delete(pendingCredentialDraft)
+    .where(
+      and(eq(pendingCredentialDraft.userId, userId), lt(pendingCredentialDraft.expiresAt, now))
+    )
+  await db
+    .insert(pendingCredentialDraft)
+    .values({
+      id: crypto.randomUUID(),
+      userId,
+      workspaceId,
+      providerId,
+      displayName,
+      expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
+      createdAt: now,
+    })
+    .onConflictDoUpdate({
+      target: [
+        pendingCredentialDraft.userId,
+        pendingCredentialDraft.providerId,
+        pendingCredentialDraft.workspaceId,
+      ],
+      set: {
+        displayName,
+        expiresAt: new Date(now.getTime() + 15 * 60 * 1000),
+        createdAt: now,
+      },
+    })
+
+  const { auth } = await import('@/lib/auth/auth')
+  const { headers: getHeaders } = await import('next/headers')
+  const reqHeaders = await getHeaders()
+
+  const data = (await auth.api.oAuth2LinkAccount({
+    body: { providerId, callbackURL },
+    headers: reqHeaders,
+  })) as { url?: string; redirect?: boolean }
+
+  if (!data?.url) {
+    throw new Error('oAuth2LinkAccount did not return an authorization URL')
+  }
+
+  return { url: data.url, providerId, serviceName }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/param-types.ts b/apps/sim/lib/copilot/tools/handlers/param-types.ts
similarity index 83%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/param-types.ts
rename to apps/sim/lib/copilot/tools/handlers/param-types.ts
index 660e62d67b0..d2e3a4f5656 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/param-types.ts
+++ b/apps/sim/lib/copilot/tools/handlers/param-types.ts
@@ -3,6 +3,8 @@
  * Replaces Record<string, any> with specific shapes based on actual property access.
  */
 
+import type { MothershipResourceType } from '@/lib/copilot/resources/types'
+
 // === Workflow Query Params ===
 
 export interface GetWorkflowDataParams {
@@ -44,6 +46,8 @@ export interface RunWorkflowParams {
   workflowId?: string
   workflow_input?: unknown
   input?: unknown
+  /** Optional trigger block ID when the workflow has multiple entrypoints and the caller wants a specific one. */
+  triggerBlockId?: string
   /** When true, runs the deployed version instead of the draft. Default: false (draft). */
   useDeployedState?: boolean
 }
@@ -52,6 +56,8 @@ export interface RunWorkflowUntilBlockParams {
   workflowId?: string
   workflow_input?: unknown
   input?: unknown
+  /** Optional trigger block ID when the workflow has multiple entrypoints and the caller wants a specific one. */
+  triggerBlockId?: string
   /** The block ID to stop after. Execution halts once this block completes. */
   stopAfterBlockId: string
   /** When true, runs the deployed version instead of the draft. Default: false (draft). */
@@ -101,6 +107,12 @@ export interface SetGlobalWorkflowVariablesParams {
   operations?: VariableOperation[]
 }
 
+export interface SetBlockEnabledParams {
+  workflowId?: string
+  blockId: string
+  enabled: boolean
+}
+
 // === Deployment Params ===
 
 export interface DeployApiParams {
@@ -114,13 +126,16 @@ export interface DeployChatParams {
   identifier?: string
   title?: string
   description?: string
+  welcomeMessage?: string
   customizations?: {
     primaryColor?: string
     secondaryColor?: string
     welcomeMessage?: string
+    imageUrl?: string
+    /** @deprecated Prefer imageUrl for compatibility with chat deploy APIs. */
     iconUrl?: string
   }
-  authType?: 'none' | 'password' | 'public' | 'email' | 'sso'
+  authType?: 'password' | 'public' | 'email' | 'sso'
   password?: string
   subdomain?: string
   allowedEmails?: string[]
@@ -170,11 +185,11 @@ export interface UpdateWorkflowParams {
 }
 
 export interface DeleteWorkflowParams {
-  workflowId: string
+  workflowIds: string[]
 }
 
 export interface MoveWorkflowParams {
-  workflowId: string
+  workflowIds: string[]
   folderId: string | null
 }
 
@@ -189,7 +204,7 @@ export interface RenameFolderParams {
 }
 
 export interface DeleteFolderParams {
-  folderId: string
+  folderIds: string[]
 }
 
 export interface UpdateWorkspaceMcpServerParams {
@@ -203,9 +218,15 @@ export interface DeleteWorkspaceMcpServerParams {
   serverId: string
 }
 
-export type OpenResourceType = 'workflow' | 'table' | 'knowledgebase' | 'file'
+export type OpenResourceType = MothershipResourceType
+
+export interface OpenResourceItem {
+  type?: OpenResourceType
+  id?: string
+}
 
 export interface OpenResourceParams {
+  resources?: OpenResourceItem[]
   type?: OpenResourceType
   id?: string
 }
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/platform-actions.ts b/apps/sim/lib/copilot/tools/handlers/platform-actions.ts
similarity index 100%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/platform-actions.ts
rename to apps/sim/lib/copilot/tools/handlers/platform-actions.ts
diff --git a/apps/sim/lib/copilot/tools/handlers/platform.ts b/apps/sim/lib/copilot/tools/handlers/platform.ts
new file mode 100644
index 00000000000..f5cc43f910b
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/platform.ts
@@ -0,0 +1,9 @@
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { PLATFORM_ACTIONS_CONTENT } from './platform-actions'
+
+export async function executeGetPlatformActions(
+  _rawParams: Record<string, unknown>,
+  _context: ExecutionContext
+): Promise<ToolCallResult> {
+  return { success: true, output: { content: PLATFORM_ACTIONS_CONTENT } }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/resources.ts b/apps/sim/lib/copilot/tools/handlers/resources.ts
new file mode 100644
index 00000000000..cae410bf8cc
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/resources.ts
@@ -0,0 +1,124 @@
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { type MothershipResource, MothershipResourceType } from '@/lib/copilot/resources/types'
+import { getKnowledgeBaseById } from '@/lib/knowledge/service'
+import { getLogById } from '@/lib/logs/service'
+import { getTableById } from '@/lib/table/service'
+import { getWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { getWorkflowById } from '@/lib/workflows/utils'
+import { isUuid } from '@/executor/constants'
+import type { OpenResourceItem, OpenResourceParams, ValidOpenResourceParams } from './param-types'
+
+const VALID_OPEN_RESOURCE_TYPES = new Set(Object.values(MothershipResourceType))
+
+async function resolveResource(
+  item: ValidOpenResourceParams,
+  context: ExecutionContext
+): Promise<MothershipResource | { error: string }> {
+  const resourceType = item.type
+  let resourceId = item.id
+  let title: string = resourceType
+
+  if (resourceType === 'file') {
+    if (!context.workspaceId)
+      return { error: 'Opening a workspace file requires workspace context.' }
+    if (!isUuid(item.id))
+      return { error: 'open_resource for files requires the canonical file UUID.' }
+    const record = await getWorkspaceFile(context.workspaceId, item.id)
+    if (!record) return { error: `No workspace file with id "${item.id}".` }
+    resourceId = record.id
+    title = record.name
+  }
+  if (resourceType === 'workflow') {
+    const wf = await getWorkflowById(item.id)
+    if (!wf) return { error: `No workflow with id "${item.id}".` }
+    if (context.workspaceId && wf.workspaceId !== context.workspaceId)
+      return { error: `Workflow not found in the current workspace.` }
+    resourceId = wf.id
+    title = wf.name
+  }
+  if (resourceType === 'table') {
+    const tbl = await getTableById(item.id)
+    if (!tbl) return { error: `No table with id "${item.id}".` }
+    if (context.workspaceId && tbl.workspaceId !== context.workspaceId)
+      return { error: `Table not found in the current workspace.` }
+    resourceId = tbl.id
+    title = tbl.name
+  }
+  if (resourceType === 'knowledgebase') {
+    const kb = await getKnowledgeBaseById(item.id)
+    if (!kb) return { error: `No knowledge base with id "${item.id}".` }
+    if (context.workspaceId && kb.workspaceId !== context.workspaceId)
+      return { error: `Knowledge base not found in the current workspace.` }
+    resourceId = kb.id
+    title = kb.name
+  }
+  if (resourceType === 'log') {
+    const logRecord = await getLogById(item.id)
+    if (!logRecord) return { error: `No log with id "${item.id}".` }
+    if (context.workspaceId && logRecord.workspaceId !== context.workspaceId)
+      return { error: `Log not found in the current workspace.` }
+    resourceId = logRecord.id
+    const workflowName = logRecord.workflowName ?? 'Unknown Workflow'
+    const timestamp = logRecord.startedAt.toLocaleString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+    })
+    title = `${workflowName} — ${timestamp}`
+  }
+
+  return { type: resourceType, id: resourceId, title }
+}
+
+export async function executeOpenResource(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as OpenResourceParams
+
+  const items: OpenResourceItem[] =
+    params.resources ?? (params.type && params.id ? [{ type: params.type, id: params.id }] : [])
+
+  if (items.length === 0) {
+    return { success: false, error: 'resources array is required' }
+  }
+
+  const resources: MothershipResource[] = []
+  const errors: string[] = []
+
+  for (const item of items) {
+    const validated = validateOpenResourceItem(item)
+    if (!validated.success) {
+      errors.push(validated.error)
+      continue
+    }
+    const result = await resolveResource(validated.params, context)
+    if ('error' in result) {
+      errors.push(result.error)
+    } else {
+      resources.push(result)
+    }
+  }
+
+  return {
+    success: resources.length > 0,
+    output: { opened: resources.length, errors },
+    resources,
+  }
+}
+
+function validateOpenResourceItem(
+  item: OpenResourceItem
+): { success: true; params: ValidOpenResourceParams } | { success: false; error: string } {
+  if (!item.type) {
+    return { success: false, error: 'type is required' }
+  }
+  if (!VALID_OPEN_RESOURCE_TYPES.has(item.type)) {
+    return { success: false, error: `Invalid resource type: ${item.type}` }
+  }
+  if (!item.id) {
+    return { success: false, error: `${item.type} resources require \`id\`` }
+  }
+  return { success: true, params: { type: item.type, id: item.id } }
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/restore-resource.ts b/apps/sim/lib/copilot/tools/handlers/restore-resource.ts
new file mode 100644
index 00000000000..3954d08fbfe
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/restore-resource.ts
@@ -0,0 +1,106 @@
+import { createLogger } from '@sim/logger'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { generateId } from '@/lib/core/utils/uuid'
+import { restoreKnowledgeBase } from '@/lib/knowledge/service'
+import { getTableById, restoreTable } from '@/lib/table/service'
+import {
+  getWorkspaceFile,
+  restoreWorkspaceFile,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { restoreWorkflow } from '@/lib/workflows/lifecycle'
+import { performRestoreFolder } from '@/lib/workflows/orchestration/folder-lifecycle'
+
+const logger = createLogger('RestoreResource')
+
+const VALID_TYPES = new Set(['workflow', 'table', 'file', 'knowledgebase', 'folder'])
+
+export async function executeRestoreResource(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const type = rawParams.type as string | undefined
+  const id = rawParams.id as string | undefined
+
+  if (!type || !VALID_TYPES.has(type)) {
+    return { success: false, error: `Invalid type. Must be one of: ${[...VALID_TYPES].join(', ')}` }
+  }
+  if (!id) {
+    return { success: false, error: 'id is required' }
+  }
+  if (!context.workspaceId) {
+    return { success: false, error: 'Workspace context required' }
+  }
+
+  const requestId = generateId().slice(0, 8)
+
+  try {
+    switch (type) {
+      case 'workflow': {
+        const result = await restoreWorkflow(id, { requestId })
+        if (!result.restored) {
+          return { success: false, error: 'Workflow not found or not archived' }
+        }
+        logger.info('Workflow restored via copilot', { workflowId: id })
+        return {
+          success: true,
+          output: { type, id, name: result.workflow?.name },
+          resources: [{ type: 'workflow', id, title: result.workflow?.name || id }],
+        }
+      }
+
+      case 'table': {
+        await restoreTable(id, requestId)
+        const table = await getTableById(id)
+        const tableName = table?.name || id
+        logger.info('Table restored via copilot', { tableId: id, name: tableName })
+        return {
+          success: true,
+          output: { type, id, name: tableName },
+          resources: [{ type: 'table', id, title: tableName }],
+        }
+      }
+
+      case 'file': {
+        await restoreWorkspaceFile(context.workspaceId, id)
+        const fileRecord = await getWorkspaceFile(context.workspaceId, id)
+        const fileName = fileRecord?.name || id
+        logger.info('File restored via copilot', { fileId: id, name: fileName })
+        return {
+          success: true,
+          output: { type, id, name: fileName },
+          resources: [{ type: 'file', id, title: fileName }],
+        }
+      }
+
+      case 'knowledgebase': {
+        await restoreKnowledgeBase(id, requestId)
+        logger.info('Knowledge base restored via copilot', { knowledgeBaseId: id })
+        return {
+          success: true,
+          output: { type, id },
+        }
+      }
+
+      case 'folder': {
+        const result = await performRestoreFolder({
+          folderId: id,
+          workspaceId: context.workspaceId,
+          userId: context.userId,
+        })
+        if (!result.success) {
+          return { success: false, error: result.error || 'Failed to restore folder' }
+        }
+        logger.info('Folder restored via copilot', { folderId: id })
+        return {
+          success: true,
+          output: { type, id, restoredItems: result.restoredItems },
+        }
+      }
+
+      default:
+        return { success: false, error: `Unsupported type: ${type}` }
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/upload-file-reader.ts b/apps/sim/lib/copilot/tools/handlers/upload-file-reader.ts
similarity index 100%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/upload-file-reader.ts
rename to apps/sim/lib/copilot/tools/handlers/upload-file-reader.ts
diff --git a/apps/sim/lib/copilot/tools/handlers/vfs.test.ts b/apps/sim/lib/copilot/tools/handlers/vfs.test.ts
new file mode 100644
index 00000000000..7ec15c7d087
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/vfs.test.ts
@@ -0,0 +1,94 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { TOOL_RESULT_MAX_INLINE_CHARS } from '@/lib/copilot/constants'
+
+const { getOrMaterializeVFS } = vi.hoisted(() => ({
+  getOrMaterializeVFS: vi.fn(),
+}))
+
+const { readChatUpload } = vi.hoisted(() => ({
+  readChatUpload: vi.fn(),
+}))
+
+vi.mock('@sim/logger', () => loggerMock)
+vi.mock('@/lib/copilot/vfs', () => ({
+  getOrMaterializeVFS,
+}))
+vi.mock('./upload-file-reader', () => ({
+  readChatUpload,
+  listChatUploads: vi.fn(),
+}))
+
+import { executeVfsGrep, executeVfsRead } from './vfs'
+
+const OVERSIZED_INLINE_CONTENT = 'x'.repeat(TOOL_RESULT_MAX_INLINE_CHARS + 1)
+
+function makeVfs() {
+  return {
+    grep: vi.fn(),
+    read: vi.fn(),
+    readFileContent: vi.fn(),
+    suggestSimilar: vi.fn().mockReturnValue([]),
+  }
+}
+
+describe('vfs handlers oversize policy', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('fails oversized grep results with narrowing guidance', async () => {
+    const vfs = makeVfs()
+    vfs.grep.mockReturnValue([{ path: 'files/a.txt', line: 1, content: OVERSIZED_INLINE_CONTENT }])
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsGrep(
+      { pattern: 'foo', output_mode: 'content' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('more specific pattern')
+    expect(result.error).toContain('context window')
+  })
+
+  it('fails oversized read results with grep guidance', async () => {
+    const vfs = makeVfs()
+    vfs.read.mockReturnValue({ content: OVERSIZED_INLINE_CONTENT, totalLines: 1 })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.txt' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Use grep')
+    expect(result.error).toContain('offset/limit')
+    expect(result.error).toContain('context window')
+  })
+
+  it('fails file-backed oversized read placeholders with grep guidance', async () => {
+    const vfs = makeVfs()
+    vfs.read.mockReturnValue(null)
+    vfs.readFileContent.mockResolvedValue({
+      content: '[File too large to display inline: big.txt (6000000 bytes, limit 5242880)]',
+      totalLines: 1,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.txt' },
+      { userId: 'user-1', workflowId: 'wf-1', workspaceId: 'ws-1' }
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Use grep')
+    expect(result.error).toContain('offset/limit')
+    expect(result.error).toContain('context window')
+  })
+})
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/vfs-tools.ts b/apps/sim/lib/copilot/tools/handlers/vfs.ts
similarity index 56%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/vfs-tools.ts
rename to apps/sim/lib/copilot/tools/handlers/vfs.ts
index c2e37759436..67430f61fd2 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/vfs-tools.ts
+++ b/apps/sim/lib/copilot/tools/handlers/vfs.ts
@@ -1,10 +1,34 @@
 import { createLogger } from '@sim/logger'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import { TOOL_RESULT_MAX_INLINE_CHARS } from '@/lib/copilot/constants'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { getOrMaterializeVFS } from '@/lib/copilot/vfs'
 import { listChatUploads, readChatUpload } from './upload-file-reader'
 
 const logger = createLogger('VfsTools')
 
+function serializedResultSize(value: unknown): number {
+  try {
+    return JSON.stringify(value).length
+  } catch {
+    return String(value).length
+  }
+}
+
+function isOversizedReadPlaceholder(content: string): boolean {
+  return (
+    content.startsWith('[File too large to display inline:') ||
+    content.startsWith('[Image too large:')
+  )
+}
+
+function hasImageAttachment(result: unknown): boolean {
+  if (!result || typeof result !== 'object') {
+    return false
+  }
+  const attachment = (result as { attachment?: { type?: string } }).attachment
+  return attachment?.type === 'image'
+}
+
 export async function executeVfsGrep(
   params: Record<string, unknown>,
   context: ExecutionContext
@@ -13,6 +37,7 @@ export async function executeVfsGrep(
   if (!pattern) {
     return { success: false, error: "Missing required parameter 'pattern'" }
   }
+  const outputMode = (params.output_mode as string) ?? 'content'
 
   const workspaceId = context.workspaceId
   if (!workspaceId) {
@@ -23,12 +48,11 @@ export async function executeVfsGrep(
     const vfs = await getOrMaterializeVFS(workspaceId, context.userId)
     const result = vfs.grep(pattern, params.path as string | undefined, {
       maxResults: (params.maxResults as number) ?? 50,
-      outputMode: (params.output_mode as 'content' | 'files_with_matches' | 'count') ?? 'content',
+      outputMode: outputMode as 'content' | 'files_with_matches' | 'count',
       ignoreCase: (params.ignoreCase as boolean) ?? false,
       lineNumbers: (params.lineNumbers as boolean) ?? true,
       context: (params.context as number) ?? 0,
     })
-    const outputMode = (params.output_mode as string) ?? 'content'
     const key =
       outputMode === 'files_with_matches' ? 'files' : outputMode === 'count' ? 'counts' : 'matches'
     const matchCount = Array.isArray(result)
@@ -36,8 +60,16 @@ export async function executeVfsGrep(
       : typeof result === 'object'
         ? Object.keys(result).length
         : 0
+    const output = { [key]: result }
+    if (serializedResultSize(output) > TOOL_RESULT_MAX_INLINE_CHARS) {
+      return {
+        success: false,
+        error:
+          'Grep result too large to return inline. Retry grep with a more specific pattern or narrower path, and reduce context or maxResults. Avoid catch-all greps because smaller searches save context window and make follow-up reads cheaper.',
+      }
+    }
     logger.debug('vfs_grep result', { pattern, path: params.path, outputMode, matchCount })
-    return { success: true, output: { [key]: result } }
+    return { success: true, output }
   } catch (err) {
     logger.error('vfs_grep failed', {
       pattern,
@@ -98,6 +130,28 @@ export async function executeVfsRead(
   }
 
   try {
+    const parseOptionalNumber = (value: unknown): number | undefined => {
+      if (typeof value === 'number' && Number.isFinite(value)) return value
+      if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Number.parseInt(value, 10)
+        return Number.isFinite(parsed) ? parsed : undefined
+      }
+      return undefined
+    }
+    const offset = parseOptionalNumber(params.offset)
+    const limit = parseOptionalNumber(params.limit)
+    const applyWindow = <T extends { content: string; totalLines: number }>(result: T): T => {
+      if (offset === undefined && limit === undefined) return result
+      const lines = result.content.split('\n')
+      const start = Math.max(0, Math.min(result.totalLines, offset ?? 0))
+      const endRaw = limit !== undefined ? start + Math.max(0, limit) : result.totalLines
+      const end = Math.max(start, Math.min(result.totalLines, endRaw))
+      return {
+        ...result,
+        content: lines.slice(start, end).join('\n'),
+      }
+    }
+
     // Handle chat-scoped uploads via the uploads/ virtual prefix
     if (path.startsWith('uploads/')) {
       if (!context.chatId) {
@@ -106,8 +160,25 @@ export async function executeVfsRead(
       const filename = path.slice('uploads/'.length)
       const uploadResult = await readChatUpload(filename, context.chatId)
       if (uploadResult) {
-        logger.debug('vfs_read resolved chat upload', { path, totalLines: uploadResult.totalLines })
-        return { success: true, output: uploadResult }
+        if (
+          !hasImageAttachment(uploadResult) &&
+          (isOversizedReadPlaceholder(uploadResult.content) ||
+            serializedResultSize(uploadResult) > TOOL_RESULT_MAX_INLINE_CHARS)
+        ) {
+          return {
+            success: false,
+            error:
+              'Read result too large to return inline. Use grep with a more specific pattern or narrower path to locate the relevant section, then retry read with offset/limit. Avoid catch-all greps or full-file reads because they waste context window.',
+          }
+        }
+        const windowedUpload = applyWindow(uploadResult)
+        logger.debug('vfs_read resolved chat upload', {
+          path,
+          totalLines: uploadResult.totalLines,
+          offset,
+          limit,
+        })
+        return { success: true, output: windowedUpload }
       }
       return {
         success: false,
@@ -116,21 +187,31 @@ export async function executeVfsRead(
     }
 
     const vfs = await getOrMaterializeVFS(workspaceId, context.userId)
-    const result = vfs.read(
-      path,
-      params.offset as number | undefined,
-      params.limit as number | undefined
-    )
+    const result = vfs.read(path, offset, limit)
     if (!result) {
       const fileContent = await vfs.readFileContent(path)
       if (fileContent) {
+        if (
+          !hasImageAttachment(fileContent) &&
+          (isOversizedReadPlaceholder(fileContent.content) ||
+            serializedResultSize(fileContent) > TOOL_RESULT_MAX_INLINE_CHARS)
+        ) {
+          return {
+            success: false,
+            error:
+              'Read result too large to return inline. Use grep with a more specific pattern or narrower path to locate the relevant section, then retry read with offset/limit. Avoid catch-all greps or full-file reads because they waste context window.',
+          }
+        }
+        const windowedFileContent = applyWindow(fileContent)
         logger.debug('vfs_read resolved workspace file', {
           path,
           totalLines: fileContent.totalLines,
+          offset,
+          limit,
         })
         return {
           success: true,
-          output: fileContent,
+          output: windowedFileContent,
         }
       }
 
@@ -142,7 +223,18 @@ export async function executeVfsRead(
           : ' Use glob to discover available paths.'
       return { success: false, error: `File not found: ${path}.${hint}` }
     }
-    logger.debug('vfs_read result', { path, totalLines: result.totalLines })
+    if (
+      !hasImageAttachment(result) &&
+      (isOversizedReadPlaceholder(result.content) ||
+        serializedResultSize(result) > TOOL_RESULT_MAX_INLINE_CHARS)
+    ) {
+      return {
+        success: false,
+        error:
+          'Read result too large to return inline. Use grep with a more specific pattern or narrower path to locate the relevant section, then retry read with offset/limit. Avoid catch-all greps or full-file reads because they waste context window.',
+      }
+    }
+    logger.debug('vfs_read result', { path, totalLines: result.totalLines, offset, limit })
     return {
       success: true,
       output: result,
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/mutations.ts b/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
similarity index 71%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/mutations.ts
rename to apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
index 615fcdee647..4168e681bf5 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/mutations.ts
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
@@ -1,7 +1,10 @@
+import { db, workflow as workflowTable } from '@sim/db'
 import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
 import { createWorkspaceApiKey } from '@/lib/api-key/auth'
 import { AuditAction, AuditResourceType, recordAudit } from '@/lib/audit/log'
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { env } from '@/lib/core/config/env'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { generateId } from '@/lib/core/utils/uuid'
 import { executeWorkflow } from '@/lib/workflows/executor/execute-workflow'
@@ -10,7 +13,10 @@ import {
   getLatestExecutionState,
 } from '@/lib/workflows/executor/execution-state'
 import { performDeleteFolder, performDeleteWorkflow } from '@/lib/workflows/orchestration'
-import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
+import {
+  loadWorkflowFromNormalizedTables,
+  saveWorkflowToNormalizedTables,
+} from '@/lib/workflows/persistence/utils'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import {
   checkForCircularReference,
@@ -22,6 +28,7 @@ import {
   updateWorkflowRecord,
 } from '@/lib/workflows/utils'
 import { hasExecutionResult } from '@/executor/utils/errors'
+import type { BlockState, WorkflowState } from '@/stores/workflows/workflow/types'
 import { ensureWorkflowAccess, ensureWorkspaceAccess, getDefaultWorkspaceId } from '../access'
 
 function stripBinaryFields(value: unknown): unknown {
@@ -71,6 +78,88 @@ function buildExecutionError(error: unknown): ToolCallResult {
   return { success: false, error: message }
 }
 
+function resolveRunWorkflowInput(params: { workflow_input?: unknown; input?: unknown }): unknown {
+  if (Object.hasOwn(params, 'workflow_input')) {
+    return params.workflow_input
+  }
+  if (Object.hasOwn(params, 'input')) {
+    return params.input
+  }
+  return undefined
+}
+
+function resolveRunTriggerBlockId(params: { triggerBlockId?: unknown }): string | undefined {
+  return typeof params.triggerBlockId === 'string' && params.triggerBlockId.trim().length > 0
+    ? params.triggerBlockId
+    : undefined
+}
+
+function isBlockProtected(blockId: string, blocksById: Record<string, BlockState>): boolean {
+  const block = blocksById[blockId]
+  if (!block) return false
+  if (block.locked) return true
+
+  const visited = new Set<string>()
+  let parentId = block.data?.parentId
+  while (parentId && !visited.has(parentId)) {
+    visited.add(parentId)
+    if (blocksById[parentId]?.locked) return true
+    parentId = blocksById[parentId]?.data?.parentId
+  }
+
+  return false
+}
+
+function hasDisabledAncestor(blockId: string, blocksById: Record<string, BlockState>): boolean {
+  const visited = new Set<string>()
+  let parentId = blocksById[blockId]?.data?.parentId
+
+  while (parentId && !visited.has(parentId)) {
+    visited.add(parentId)
+    const parent = blocksById[parentId]
+    if (!parent) return false
+    if (parent.enabled === false) return true
+    parentId = parent.data?.parentId
+  }
+
+  return false
+}
+
+function findDescendants(containerId: string, blocksById: Record<string, BlockState>): string[] {
+  const descendants: string[] = []
+  const stack = [containerId]
+  const visited = new Set<string>()
+
+  while (stack.length > 0) {
+    const current = stack.pop()!
+    if (visited.has(current)) continue
+    visited.add(current)
+
+    for (const [blockId, block] of Object.entries(blocksById)) {
+      if (block.data?.parentId === current) {
+        descendants.push(blockId)
+        stack.push(blockId)
+      }
+    }
+  }
+
+  return descendants
+}
+
+function notifyWorkflowUpdated(workflowId: string): void {
+  const socketUrl = env.SOCKET_SERVER_URL || 'http://localhost:3002'
+  fetch(`${socketUrl}/api/workflow-updated`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': env.INTERNAL_API_SECRET,
+    },
+    body: JSON.stringify({ workflowId }),
+  }).catch((error) => {
+    logger.warn('Failed to notify socket server of workflow update', { workflowId, error })
+  })
+}
+
 import type {
   CreateFolderParams,
   CreateWorkflowParams,
@@ -85,6 +174,7 @@ import type {
   RunFromBlockParams,
   RunWorkflowParams,
   RunWorkflowUntilBlockParams,
+  SetBlockEnabledParams,
   SetGlobalWorkflowVariablesParams,
   UpdateWorkflowParams,
   VariableOperation,
@@ -252,9 +342,14 @@ export async function executeRunWorkflow(
         variables: workflowRecord.variables || {},
       },
       generateRequestId(),
-      params.workflow_input || params.input || undefined,
+      resolveRunWorkflowInput(params),
       context.userId,
-      { enabled: true, useDraftState, workflowTriggerType: 'copilot' }
+      {
+        enabled: true,
+        useDraftState,
+        workflowTriggerType: 'copilot',
+        triggerBlockId: resolveRunTriggerBlockId(params),
+      }
     )
 
     return buildExecutionOutput(result)
@@ -415,17 +510,27 @@ export async function executeMoveWorkflow(
   context: ExecutionContext
 ): Promise<ToolCallResult> {
   try {
-    const workflowId = params.workflowId
-    if (!workflowId) {
-      return { success: false, error: 'workflowId is required' }
+    const workflowIds = params.workflowIds
+    if (!workflowIds || workflowIds.length === 0) {
+      return { success: false, error: 'workflowIds is required' }
     }
 
-    await ensureWorkflowAccess(workflowId, context.userId, 'write')
     const folderId = params.folderId || null
-    assertWorkflowMutationNotAborted(context)
-    await updateWorkflowRecord(workflowId, { folderId })
+    const moved: string[] = []
+    const failed: string[] = []
+
+    for (const workflowId of workflowIds) {
+      try {
+        await ensureWorkflowAccess(workflowId, context.userId, 'write')
+        assertWorkflowMutationNotAborted(context)
+        await updateWorkflowRecord(workflowId, { folderId })
+        moved.push(workflowId)
+      } catch {
+        failed.push(workflowId)
+      }
+    }
 
-    return { success: true, output: { workflowId, folderId } }
+    return { success: moved.length > 0, output: { moved, failed, folderId } }
   } catch (error) {
     return { success: false, error: error instanceof Error ? error.message : String(error) }
   }
@@ -494,13 +599,14 @@ export async function executeRunWorkflowUntilBlock(
         variables: workflowRecord.variables || {},
       },
       generateRequestId(),
-      params.workflow_input || params.input || undefined,
+      resolveRunWorkflowInput(params),
       context.userId,
       {
         enabled: true,
         useDraftState,
         stopAfterBlockId: params.stopAfterBlockId,
         workflowTriggerType: 'copilot',
+        triggerBlockId: resolveRunTriggerBlockId(params),
       }
     )
 
@@ -602,7 +708,7 @@ export async function executeRunFromBlock(
         variables: workflowRecord.variables || {},
       },
       generateRequestId(),
-      params.workflow_input || params.input || undefined,
+      resolveRunWorkflowInput(params),
       context.userId,
       {
         enabled: true,
@@ -662,31 +768,173 @@ export async function executeUpdateWorkflow(
   }
 }
 
-export async function executeDeleteWorkflow(
-  params: DeleteWorkflowParams,
+export async function executeSetBlockEnabled(
+  params: SetBlockEnabledParams,
   context: ExecutionContext
 ): Promise<ToolCallResult> {
   try {
-    const workflowId = params.workflowId
+    const workflowId = params.workflowId || context.workflowId
     if (!workflowId) {
       return { success: false, error: 'workflowId is required' }
     }
+    if (!params.blockId) {
+      return { success: false, error: 'blockId is required' }
+    }
+    if (typeof params.enabled !== 'boolean') {
+      return { success: false, error: 'enabled must be a boolean' }
+    }
 
     const { workflow: workflowRecord } = await ensureWorkflowAccess(
       workflowId,
       context.userId,
-      'admin'
+      'write'
     )
     assertWorkflowMutationNotAborted(context)
 
-    const result = await performDeleteWorkflow({ workflowId, userId: context.userId })
-    if (!result.success) {
-      return { success: false, error: result.error || 'Failed to delete workflow' }
+    const normalized = await loadWorkflowFromNormalizedTables(workflowId)
+    if (!normalized) {
+      return { success: false, error: `Workflow ${workflowId} has no normalized state` }
+    }
+
+    const currentState: WorkflowState = {
+      blocks: normalized.blocks as Record<string, BlockState>,
+      edges: normalized.edges || [],
+      loops: normalized.loops || {},
+      parallels: normalized.parallels || {},
+      lastSaved: Date.now(),
     }
 
+    const currentBlocks = currentState.blocks
+    const targetBlock = currentBlocks[params.blockId]
+    if (!targetBlock) {
+      return {
+        success: false,
+        error: `Block ${params.blockId} not found in workflow ${workflowId}`,
+      }
+    }
+    if (isBlockProtected(params.blockId, currentBlocks)) {
+      return {
+        success: false,
+        error: `Block ${params.blockId} is locked or inside a locked container and cannot be updated`,
+      }
+    }
+    if (targetBlock.enabled === params.enabled) {
+      return {
+        success: true,
+        output: {
+          workflowId,
+          workflowName: workflowRecord.name,
+          blockId: params.blockId,
+          enabled: params.enabled,
+          affectedBlockIds: [params.blockId],
+          workflowState: currentState,
+          copilotSanitizedWorkflowState: sanitizeForCopilot(currentState),
+          message: `Block ${params.blockId} is already ${params.enabled ? 'enabled' : 'disabled'}`,
+        },
+      }
+    }
+    if (params.enabled && hasDisabledAncestor(params.blockId, currentBlocks)) {
+      return {
+        success: false,
+        error: `Cannot enable block ${params.blockId} while one of its parent containers is disabled. Enable the parent first.`,
+      }
+    }
+
+    const affectedBlockIds = new Set<string>([params.blockId])
+    if (targetBlock.type === 'loop' || targetBlock.type === 'parallel') {
+      for (const descendantId of findDescendants(params.blockId, currentBlocks)) {
+        if (!isBlockProtected(descendantId, currentBlocks)) {
+          affectedBlockIds.add(descendantId)
+        }
+      }
+    }
+
+    const nextBlocks: Record<string, BlockState> = { ...currentBlocks }
+    for (const blockId of affectedBlockIds) {
+      nextBlocks[blockId] = {
+        ...nextBlocks[blockId],
+        enabled: params.enabled,
+      }
+    }
+
+    const nextState: WorkflowState = {
+      ...currentState,
+      blocks: nextBlocks,
+      lastSaved: Date.now(),
+    }
+
+    assertWorkflowMutationNotAborted(context)
+    const saveResult = await saveWorkflowToNormalizedTables(workflowId, nextState)
+    if (!saveResult.success) {
+      return {
+        success: false,
+        error: saveResult.error || `Failed to persist enabled state for block ${params.blockId}`,
+      }
+    }
+
+    await db
+      .update(workflowTable)
+      .set({
+        lastSynced: new Date(),
+        updatedAt: new Date(),
+      })
+      .where(eq(workflowTable.id, workflowId))
+
+    notifyWorkflowUpdated(workflowId)
+
     return {
       success: true,
-      output: { workflowId, name: workflowRecord.name, deleted: true },
+      output: {
+        workflowId,
+        workflowName: workflowRecord.name,
+        blockId: params.blockId,
+        enabled: params.enabled,
+        affectedBlockIds: Array.from(affectedBlockIds),
+        workflowState: nextState,
+        copilotSanitizedWorkflowState: sanitizeForCopilot(nextState),
+      },
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+export async function executeDeleteWorkflow(
+  params: DeleteWorkflowParams,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  try {
+    const workflowIds = params.workflowIds
+    if (!workflowIds || workflowIds.length === 0) {
+      return { success: false, error: 'workflowIds is required' }
+    }
+
+    const deleted: Array<{ workflowId: string; name: string }> = []
+    const failed: string[] = []
+
+    for (const workflowId of workflowIds) {
+      try {
+        const { workflow: workflowRecord } = await ensureWorkflowAccess(
+          workflowId,
+          context.userId,
+          'admin'
+        )
+        assertWorkflowMutationNotAborted(context)
+
+        const result = await performDeleteWorkflow({ workflowId, userId: context.userId })
+        if (result.success) {
+          deleted.push({ workflowId, name: workflowRecord.name })
+        } else {
+          failed.push(workflowId)
+        }
+      } catch {
+        failed.push(workflowId)
+      }
+    }
+
+    return {
+      success: deleted.length > 0,
+      output: { deleted, failed },
     }
   } catch (error) {
     return { success: false, error: error instanceof Error ? error.message : String(error) }
@@ -698,34 +946,42 @@ export async function executeDeleteFolder(
   context: ExecutionContext
 ): Promise<ToolCallResult> {
   try {
-    const folderId = params.folderId
-    if (!folderId) {
-      return { success: false, error: 'folderId is required' }
+    const folderIds = params.folderIds
+    if (!folderIds || folderIds.length === 0) {
+      return { success: false, error: 'folderIds is required' }
     }
 
     const workspaceId = context.workspaceId || (await getDefaultWorkspaceId(context.userId))
     await ensureWorkspaceAccess(workspaceId, context.userId, 'admin')
 
     const folders = await listFolders(workspaceId)
-    const folder = folders.find((f) => f.folderId === folderId)
-    if (!folder) {
-      return { success: false, error: 'Folder not found' }
-    }
+    const deleted: string[] = []
+    const failed: string[] = []
 
-    assertWorkflowMutationNotAborted(context)
+    for (const folderId of folderIds) {
+      const folder = folders.find((f) => f.folderId === folderId)
+      if (!folder) {
+        failed.push(folderId)
+        continue
+      }
 
-    const result = await performDeleteFolder({
-      folderId,
-      workspaceId,
-      userId: context.userId,
-      folderName: folder.folderName,
-    })
+      assertWorkflowMutationNotAborted(context)
 
-    if (!result.success) {
-      return { success: false, error: result.error || 'Failed to delete folder' }
+      const result = await performDeleteFolder({
+        folderId,
+        workspaceId,
+        userId: context.userId,
+        folderName: folder.folderName,
+      })
+
+      if (result.success) {
+        deleted.push(folderId)
+      } else {
+        failed.push(folderId)
+      }
     }
 
-    return { success: true, output: { folderId, deleted: true, ...result.deletedItems } }
+    return { success: deleted.length > 0, output: { deleted, failed } }
   } catch (error) {
     return { success: false, error: error instanceof Error ? error.message : String(error) }
   }
@@ -800,7 +1056,7 @@ export async function executeRunBlock(
         variables: workflowRecord.variables || {},
       },
       generateRequestId(),
-      params.workflow_input || params.input || undefined,
+      resolveRunWorkflowInput(params),
       context.userId,
       {
         enabled: true,
diff --git a/apps/sim/lib/copilot/tools/handlers/workflow/queries.test.ts b/apps/sim/lib/copilot/tools/handlers/workflow/queries.test.ts
new file mode 100644
index 00000000000..d238bf78878
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/queries.test.ts
@@ -0,0 +1,114 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  ensureWorkflowAccessMock,
+  loadWorkflowFromNormalizedTablesMock,
+  getEffectiveBlockOutputPathsMock,
+  hasTriggerCapabilityMock,
+  getBlockMock,
+  getWorkflowByIdMock,
+} = vi.hoisted(() => ({
+  ensureWorkflowAccessMock: vi.fn(),
+  loadWorkflowFromNormalizedTablesMock: vi.fn(),
+  getEffectiveBlockOutputPathsMock: vi.fn(),
+  hasTriggerCapabilityMock: vi.fn(),
+  getBlockMock: vi.fn(),
+  getWorkflowByIdMock: vi.fn(),
+}))
+
+vi.mock('../access', () => ({
+  ensureWorkflowAccess: ensureWorkflowAccessMock,
+  ensureWorkspaceAccess: vi.fn(),
+  getDefaultWorkspaceId: vi.fn(),
+}))
+
+vi.mock('@/lib/workflows/persistence/utils', () => ({
+  loadWorkflowFromNormalizedTables: loadWorkflowFromNormalizedTablesMock,
+  loadDeployedWorkflowState: vi.fn(),
+}))
+
+vi.mock('@/lib/workflows/blocks/block-outputs', () => ({
+  getEffectiveBlockOutputPaths: getEffectiveBlockOutputPathsMock,
+}))
+
+vi.mock('@/lib/workflows/triggers/trigger-utils', () => ({
+  hasTriggerCapability: hasTriggerCapabilityMock,
+}))
+
+vi.mock('@/blocks/registry', () => ({
+  getBlock: getBlockMock,
+}))
+
+vi.mock('@/lib/workflows/utils', () => ({
+  getWorkflowById: getWorkflowByIdMock,
+  listFolders: vi.fn(),
+}))
+
+import { executeGetBlockOutputs } from './queries'
+
+describe('executeGetBlockOutputs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    ensureWorkflowAccessMock.mockResolvedValue({
+      workflow: { id: 'wf-1', userId: 'user-1', workspaceId: 'ws-1' },
+    })
+    getWorkflowByIdMock.mockResolvedValue({ variables: {} })
+    getBlockMock.mockReturnValue({ category: 'core' })
+    hasTriggerCapabilityMock.mockReturnValue(false)
+    getEffectiveBlockOutputPathsMock.mockReturnValue(['content'])
+  })
+
+  it('returns display outputs and block-relative outputs for chat deployment', async () => {
+    loadWorkflowFromNormalizedTablesMock.mockResolvedValue({
+      blocks: {
+        'agent-1': {
+          type: 'agent',
+          name: 'Support Agent',
+          subBlocks: {},
+        },
+        'loop-1': {
+          type: 'loop',
+          name: 'Items Loop',
+        },
+      },
+      loops: {
+        'loop-1': {
+          loopType: 'forEach',
+        },
+      },
+      parallels: {},
+    })
+
+    const result = await executeGetBlockOutputs({ blockIds: ['agent-1', 'loop-1'] }, {
+      workflowId: 'wf-1',
+      userId: 'user-1',
+    } as any)
+
+    expect(result.success).toBe(true)
+    expect(result.output).toEqual({
+      blocks: [
+        {
+          blockId: 'agent-1',
+          blockName: 'Support Agent',
+          blockType: 'agent',
+          outputs: ['supportagent.content'],
+          relativeOutputs: ['content'],
+          triggerMode: undefined,
+        },
+        {
+          blockId: 'loop-1',
+          blockName: 'Items Loop',
+          blockType: 'loop',
+          outputs: [],
+          relativeOutputs: [],
+          insideSubflowOutputs: ['itemsloop.index', 'itemsloop.currentItem', 'itemsloop.items'],
+          outsideSubflowOutputs: ['itemsloop.results'],
+          relativeInsideSubflowOutputs: ['index', 'currentItem', 'items'],
+          relativeOutsideSubflowOutputs: ['results'],
+          triggerMode: undefined,
+        },
+      ],
+      variables: [],
+    })
+  })
+})
diff --git a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/queries.ts b/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
similarity index 93%
rename from apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/queries.ts
rename to apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
index 2148a2c0cb1..03585eb82b3 100644
--- a/apps/sim/lib/copilot/orchestrator/tool-executor/workflow-tools/queries.ts
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
@@ -1,9 +1,10 @@
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/orchestrator/types'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { formatNormalizedWorkflowForCopilot } from '@/lib/copilot/tools/shared/workflow-utils'
 import { mcpService } from '@/lib/mcp/service'
 import { listWorkspaceFiles } from '@/lib/uploads/contexts/workspace'
 import { getEffectiveBlockOutputPaths } from '@/lib/workflows/blocks/block-outputs'
 import { BlockPathCalculator } from '@/lib/workflows/blocks/block-path-calculator'
+import { getBlockReferenceTags } from '@/lib/workflows/blocks/block-reference-tags'
 import { listCustomTools } from '@/lib/workflows/custom-tools/operations'
 import {
   loadDeployedWorkflowState,
@@ -185,8 +186,11 @@ export async function executeGetBlockOutputs(
       blockName: string
       blockType: string
       outputs: string[]
+      relativeOutputs?: string[]
       insideSubflowOutputs?: string[]
       outsideSubflowOutputs?: string[]
+      relativeInsideSubflowOutputs?: string[]
+      relativeOutsideSubflowOutputs?: string[]
       triggerMode?: boolean
     }> = []
 
@@ -202,8 +206,11 @@ export async function executeGetBlockOutputs(
           blockName,
           blockType: block.type,
           outputs: [],
-          insideSubflowOutputs: formatOutputsWithPrefix(insidePaths, blockName),
-          outsideSubflowOutputs: formatOutputsWithPrefix(['results'], blockName),
+          relativeOutputs: [],
+          insideSubflowOutputs: formatOutputsForDisplay(insidePaths, blockName),
+          outsideSubflowOutputs: formatOutputsForDisplay(['results'], blockName),
+          relativeInsideSubflowOutputs: insidePaths,
+          relativeOutsideSubflowOutputs: ['results'],
           triggerMode: block.triggerMode,
         })
         continue
@@ -220,7 +227,8 @@ export async function executeGetBlockOutputs(
         blockId,
         blockName,
         blockType: block.type,
-        outputs: formatOutputsWithPrefix(outputs, blockName),
+        outputs: formatOutputsForDisplay(outputs, blockName),
+        relativeOutputs: outputs,
         triggerMode: block.triggerMode,
       })
     }
@@ -335,27 +343,29 @@ export async function executeGetBlockUpstreamReferences(
 
         const blockName = block.name || block.type
         let accessContext: 'inside' | 'outside' | undefined
-        let outputPaths: string[]
 
+        let formattedOutputs: string[]
         if (block.type === 'loop' || block.type === 'parallel') {
           const isInside =
             (block.type === 'loop' && containingLoopIds.has(accessibleBlockId)) ||
             (block.type === 'parallel' && containingParallelIds.has(accessibleBlockId))
           accessContext = isInside ? 'inside' : 'outside'
-          outputPaths = isInside
+          const outputPaths = isInside
             ? getSubflowInsidePaths(block.type, accessibleBlockId, loops, parallels)
             : ['results']
+          formattedOutputs = formatOutputsForDisplay(outputPaths, blockName)
         } else {
-          const blockConfig = getBlock(block.type)
-          const isTriggerCapable = blockConfig ? hasTriggerCapability(blockConfig) : false
-          const triggerMode = Boolean(block.triggerMode && isTriggerCapable)
-          outputPaths = getEffectiveBlockOutputPaths(block.type, block.subBlocks, {
-            triggerMode,
-            preferToolOutputs: !triggerMode,
+          formattedOutputs = getBlockReferenceTags({
+            block: {
+              id: accessibleBlockId,
+              type: block.type,
+              name: block.name,
+              triggerMode: block.triggerMode,
+              subBlocks: block.subBlocks,
+            },
+            currentBlockId: blockId,
           })
         }
-
-        const formattedOutputs = formatOutputsWithPrefix(outputPaths, blockName)
         const entry: AccessibleBlockEntry = {
           blockId: accessibleBlockId,
           blockName,
@@ -425,7 +435,7 @@ function getSubflowInsidePaths(
   return paths
 }
 
-function formatOutputsWithPrefix(paths: string[], blockName: string): string[] {
+function formatOutputsForDisplay(paths: string[], blockName: string): string[] {
   const normalizedName = normalizeName(blockName)
   return paths.map((path) => `${normalizedName}.${path}`)
 }
diff --git a/apps/sim/lib/copilot/tools/mcp/definitions.ts b/apps/sim/lib/copilot/tools/mcp/definitions.ts
index 6ca813a3b3e..52ba61daede 100644
--- a/apps/sim/lib/copilot/tools/mcp/definitions.ts
+++ b/apps/sim/lib/copilot/tools/mcp/definitions.ts
@@ -58,7 +58,7 @@ export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
     name: 'create_workflow',
     toolId: 'create_workflow',
     description:
-      'Create a new empty workflow. Returns the new workflow ID. Always call this FIRST before sim_build for new workflows. Use workspaceId to place it in a specific workspace.',
+      'Create a new empty workflow. Returns the new workflow ID. Always call this FIRST before sim_workflow for new workflows. Use workspaceId to place it in a specific workspace.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -263,14 +263,15 @@ export const DIRECT_TOOL_DEFS: DirectToolDef[] = [
 
 export const SUBAGENT_TOOL_DEFS: SubagentToolDef[] = [
   {
-    name: 'sim_build',
-    agentId: 'build',
-    description: `Build a workflow end-to-end in a single step. This is the fast mode equivalent for headless/MCP usage.
+    name: 'sim_workflow',
+    agentId: 'workflow',
+    description: `Create, modify, test, debug, and organize workflows end-to-end in a single step.
 
 USE THIS WHEN:
 - Building a new workflow from scratch
 - Modifying an existing workflow
-- You want to gather information and build in one pass without separate plan→edit steps
+- You want to gather information and build in one pass
+- Moving, renaming, or organizing workflows and folders
 
 WORKFLOW ID (REQUIRED):
 - For NEW workflows: First call create_workflow to get a workflowId, then pass it here
@@ -282,6 +283,7 @@ CAN DO:
 - Add, modify, or remove blocks
 - Configure block settings and connections
 - Set environment variables and workflow variables
+- Move, rename, delete workflows and folders
 
 CANNOT DO:
 - Run or test workflows (use sim_test separately)
@@ -289,8 +291,8 @@ CANNOT DO:
 
 WORKFLOW:
 1. Call create_workflow to get a workflowId (for new workflows)
-2. Call sim_build with the request and workflowId
-3. Build agent gathers info and builds in one pass
+2. Call sim_workflow with the request and workflowId
+3. Workflow agent gathers info and builds in one pass
 4. Call sim_test to verify it works
 5. Optionally call sim_deploy to make it externally accessible`,
     inputSchema: {
@@ -298,7 +300,7 @@ WORKFLOW:
       properties: {
         request: {
           type: 'string',
-          description: 'What you want to build or modify in the workflow.',
+          description: 'What you want to build, modify, or organize.',
         },
         workflowId: {
           type: 'string',
@@ -337,77 +339,6 @@ DO NOT USE (use direct tools instead):
     },
     annotations: { readOnlyHint: true },
   },
-  {
-    name: 'sim_plan',
-    agentId: 'plan',
-    description: `Plan workflow changes by gathering required information. For most cases, prefer sim_build which combines planning and editing in one step.
-
-USE THIS WHEN:
-- You need fine-grained control over the build process
-- You want to inspect the plan before executing it
-
-WORKFLOW ID (REQUIRED):
-- For NEW workflows: First call create_workflow to get a workflowId, then pass it here
-- For EXISTING workflows: Always pass the workflowId parameter
-
-This tool gathers information about available blocks, credentials, and the current workflow state.
-
-RETURNS: A plan object containing block configurations, connections, and technical details.
-IMPORTANT: Pass the returned plan EXACTLY to sim_edit - do not modify or summarize it.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        request: {
-          type: 'string',
-          description: 'What you want to build or modify in the workflow.',
-        },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID. For new workflows, call create_workflow first to get this.',
-        },
-        context: { type: 'object' },
-      },
-      required: ['request', 'workflowId'],
-    },
-    annotations: { readOnlyHint: true },
-  },
-  {
-    name: 'sim_edit',
-    agentId: 'edit',
-    description: `Execute a workflow plan from sim_plan. For most cases, prefer sim_build which combines planning and editing in one step.
-
-WORKFLOW ID (REQUIRED):
-- You MUST provide the workflowId parameter
-
-PLAN (REQUIRED):
-- Pass the EXACT plan object from sim_plan in the context.plan field
-- Do NOT modify, summarize, or interpret the plan - pass it verbatim
-
-After sim_edit completes, you can test immediately with sim_test, or deploy with sim_deploy to make it accessible externally.`,
-    inputSchema: {
-      type: 'object',
-      properties: {
-        message: { type: 'string', description: 'Optional additional instructions for the edit.' },
-        workflowId: {
-          type: 'string',
-          description:
-            'REQUIRED. The workflow ID to edit. Get this from create_workflow for new workflows.',
-        },
-        plan: {
-          type: 'object',
-          description: 'The plan object from sim_plan. Pass it EXACTLY as returned, do not modify.',
-        },
-        context: {
-          type: 'object',
-          description:
-            'Additional context. Put the plan in context.plan if not using the plan field directly.',
-        },
-      },
-      required: ['workflowId'],
-    },
-    annotations: { destructiveHint: false, openWorldHint: true },
-  },
   {
     name: 'sim_deploy',
     agentId: 'deploy',
@@ -466,22 +397,6 @@ Supports full and partial execution:
     },
     annotations: { destructiveHint: false, openWorldHint: true },
   },
-  {
-    name: 'sim_debug',
-    agentId: 'debug',
-    description:
-      'Diagnose errors or unexpected workflow behavior. Provide the error message and workflowId. Returns root cause analysis and fix suggestions.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        error: { type: 'string', description: 'The error message or description of the issue.' },
-        workflowId: { type: 'string', description: 'REQUIRED. The workflow ID to debug.' },
-        context: { type: 'object' },
-      },
-      required: ['error', 'workflowId'],
-    },
-    annotations: { readOnlyHint: true },
-  },
   {
     name: 'sim_auth',
     agentId: 'auth',
diff --git a/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts
new file mode 100644
index 00000000000..d9defa43e13
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts
@@ -0,0 +1,50 @@
+import { createLogger } from '@sim/logger'
+import type { ToolExecutionResult, ToolHandler } from '@/lib/copilot/tool-executor/types'
+import { routeExecution } from '@/lib/copilot/tools/server/router'
+
+const logger = createLogger('ServerToolAdapter')
+
+export function createServerToolHandler(toolId: string): ToolHandler {
+  return async (params, context): Promise<ToolExecutionResult> => {
+    const enrichedParams = { ...params }
+    if (!enrichedParams.workflowId && context.workflowId)
+      enrichedParams.workflowId = context.workflowId
+    if (!enrichedParams.workspaceId && context.workspaceId)
+      enrichedParams.workspaceId = context.workspaceId
+
+    try {
+      const result = await routeExecution(toolId, enrichedParams, {
+        userId: context.userId,
+        workspaceId: context.workspaceId,
+        userPermission: context.userPermission ?? undefined,
+        chatId: context.chatId,
+        messageId: context.messageId,
+        abortSignal: context.abortSignal,
+      })
+
+      const rec =
+        result && typeof result === 'object' && !Array.isArray(result)
+          ? (result as Record<string, unknown>)
+          : null
+      if (rec?.success === false) {
+        const message =
+          (typeof rec.error === 'string' && rec.error) ||
+          (typeof rec.message === 'string' && rec.message) ||
+          `${toolId} failed`
+        return { success: false, error: message, output: result }
+      }
+      return { success: true, output: result }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      logger.error('Server tool execution failed', {
+        toolId,
+        error: message,
+        abortSignalAborted: context.abortSignal?.aborted ?? false,
+      })
+      return {
+        success: false,
+        error: `[${toolId}] ${message}`,
+      }
+    }
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/server/base-tool.ts b/apps/sim/lib/copilot/tools/server/base-tool.ts
index e898785c5d2..6131d552962 100644
--- a/apps/sim/lib/copilot/tools/server/base-tool.ts
+++ b/apps/sim/lib/copilot/tools/server/base-tool.ts
@@ -16,7 +16,10 @@ export function assertServerToolNotAborted(
   message = 'Request aborted before tool mutation could be applied.'
 ): void {
   if (context?.userStopSignal?.aborted) {
-    throw new Error(message)
+    const reason = context.userStopSignal.reason
+      ? ` (reason: ${String(context.userStopSignal.reason)})`
+      : ''
+    throw new Error(`${message}${reason}`)
   }
 }
 
diff --git a/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts b/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
index 91c907d7a72..209ff1673f3 100644
--- a/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
+++ b/apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-tool.ts
@@ -1,9 +1,9 @@
 import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
 import { createLogger } from '@sim/logger'
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { z } from 'zod'
+import { getCopilotToolDescription } from '@/lib/copilot/tools/descriptions'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
-import { GetBlocksMetadataInput, GetBlocksMetadataResult } from '@/lib/copilot/tools/shared/schemas'
 import { getAllowedIntegrationsFromEnv, isHosted } from '@/lib/core/config/feature-flags'
 import { getServiceAccountProviderForProviderId } from '@/lib/oauth/utils'
 import { registry as blockRegistry } from '@/blocks/registry'
@@ -100,17 +100,20 @@ export interface CopilotBlockMetadata {
   yamlDocumentation?: string
 }
 
+const GetBlocksMetadataInputSchema = z.object({ blockIds: z.array(z.string()).min(1) })
+const GetBlocksMetadataResultSchema = z.object({ metadata: z.record(z.any()) })
+
 export const getBlocksMetadataServerTool: BaseServerTool<
-  ReturnType<typeof GetBlocksMetadataInput.parse>,
-  ReturnType<typeof GetBlocksMetadataResult.parse>
+  z.infer<typeof GetBlocksMetadataInputSchema>,
+  z.infer<typeof GetBlocksMetadataResultSchema>
 > = {
   name: 'get_blocks_metadata',
-  inputSchema: GetBlocksMetadataInput,
-  outputSchema: GetBlocksMetadataResult,
+  inputSchema: GetBlocksMetadataInputSchema,
+  outputSchema: GetBlocksMetadataResultSchema,
   async execute(
-    { blockIds }: ReturnType<typeof GetBlocksMetadataInput.parse>,
+    { blockIds }: z.infer<typeof GetBlocksMetadataInputSchema>,
     context?: { userId: string }
-  ): Promise<ReturnType<typeof GetBlocksMetadataResult.parse>> {
+  ): Promise<z.infer<typeof GetBlocksMetadataResultSchema>> {
     const logger = createLogger('GetBlocksMetadataServerTool')
     logger.debug('Executing get_blocks_metadata', { count: blockIds?.length })
 
@@ -324,7 +327,7 @@ export const getBlocksMetadataServerTool: BaseServerTool<
       transformedResult[blockId] = transformBlockMetadata(metadata)
     }
 
-    return GetBlocksMetadataResult.parse({ metadata: transformedResult })
+    return GetBlocksMetadataResultSchema.parse({ metadata: transformedResult })
   },
 }
 
diff --git a/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts b/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
index bae14cfd80f..043802fbb99 100644
--- a/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
+++ b/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { docsEmbeddings } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { sql } from 'drizzle-orm'
+import { SearchDocumentation } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { generateSearchEmbedding } from '@/lib/knowledge/embeddings'
 
@@ -14,7 +15,7 @@ interface DocsSearchParams {
 const DEFAULT_DOCS_SIMILARITY_THRESHOLD = 0.3
 
 export const searchDocumentationServerTool: BaseServerTool<DocsSearchParams, any> = {
-  name: 'search_documentation',
+  name: SearchDocumentation.id,
   async execute(params: DocsSearchParams): Promise<any> {
     const logger = createLogger('SearchDocumentationServerTool')
     const { query, topK = 10, threshold } = params
diff --git a/apps/sim/lib/copilot/tools/server/files/create-file.ts b/apps/sim/lib/copilot/tools/server/files/create-file.ts
new file mode 100644
index 00000000000..997766ad1f8
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/create-file.ts
@@ -0,0 +1,84 @@
+import { createLogger } from '@sim/logger'
+import {
+  assertServerToolNotAborted,
+  type BaseServerTool,
+  type ServerToolContext,
+} from '@/lib/copilot/tools/server/base-tool'
+import {
+  getWorkspaceFileByName,
+  uploadWorkspaceFile,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { inferContentType, validateFlatWorkspaceFileName } from './workspace-file'
+
+const logger = createLogger('CreateFileServerTool')
+const CREATE_FILE_TOOL_ID = 'create_file'
+
+interface CreateFileArgs {
+  fileName: string
+  contentType?: string
+  args?: Record<string, unknown>
+}
+
+interface CreateFileResult {
+  success: boolean
+  message: string
+  data?: {
+    id: string
+    name: string
+    contentType: string
+  }
+}
+
+export const createFileServerTool: BaseServerTool<CreateFileArgs, CreateFileResult> = {
+  name: CREATE_FILE_TOOL_ID,
+  async execute(params: CreateFileArgs, context?: ServerToolContext): Promise<CreateFileResult> {
+    if (!context?.userId) {
+      throw new Error('Authentication required')
+    }
+    const workspaceId = context.workspaceId
+    if (!workspaceId) {
+      return { success: false, message: 'Workspace ID is required' }
+    }
+
+    const nested = params.args
+    const fileName = params.fileName || (nested?.fileName as string) || ''
+    const explicitType = params.contentType || (nested?.contentType as string) || undefined
+
+    const nameError = validateFlatWorkspaceFileName(fileName)
+    if (nameError) return { success: false, message: nameError }
+
+    const existingFile = await getWorkspaceFileByName(workspaceId, fileName)
+    if (existingFile) {
+      return { success: false, message: `File "${fileName}" already exists` }
+    }
+
+    const contentType = inferContentType(fileName, explicitType)
+    const emptyBuffer = Buffer.from('', 'utf-8')
+
+    assertServerToolNotAborted(context)
+    const result = await uploadWorkspaceFile(
+      workspaceId,
+      context.userId,
+      emptyBuffer,
+      fileName,
+      contentType
+    )
+
+    logger.info('File created via create_file', {
+      fileId: result.id,
+      name: fileName,
+      contentType,
+      userId: context.userId,
+    })
+
+    return {
+      success: true,
+      message: `File "${fileName}" created successfully`,
+      data: {
+        id: result.id,
+        name: result.name,
+        contentType,
+      },
+    }
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/delete-file.ts b/apps/sim/lib/copilot/tools/server/files/delete-file.ts
new file mode 100644
index 00000000000..901ac96b3ac
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/delete-file.ts
@@ -0,0 +1,75 @@
+import { createLogger } from '@sim/logger'
+import { DeleteFile } from '@/lib/copilot/generated/tool-catalog-v1'
+import {
+  assertServerToolNotAborted,
+  type BaseServerTool,
+  type ServerToolContext,
+} from '@/lib/copilot/tools/server/base-tool'
+import {
+  deleteWorkspaceFile,
+  getWorkspaceFile,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const logger = createLogger('DeleteFileServerTool')
+
+interface DeleteFileArgs {
+  fileIds?: string[]
+  fileId?: string
+  args?: Record<string, unknown>
+}
+
+interface DeleteFileResult {
+  success: boolean
+  message: string
+}
+
+export const deleteFileServerTool: BaseServerTool<DeleteFileArgs, DeleteFileResult> = {
+  name: DeleteFile.id,
+  async execute(params: DeleteFileArgs, context?: ServerToolContext): Promise<DeleteFileResult> {
+    if (!context?.userId) {
+      throw new Error('Authentication required')
+    }
+    const workspaceId = context.workspaceId
+    if (!workspaceId) {
+      return { success: false, message: 'Workspace ID is required' }
+    }
+
+    const nested = params.args
+    const fileIds: string[] =
+      params.fileIds ??
+      (nested?.fileIds as string[] | undefined) ??
+      [params.fileId || (nested?.fileId as string) || ''].filter(Boolean)
+
+    if (fileIds.length === 0) return { success: false, message: 'fileIds is required' }
+
+    const deleted: string[] = []
+    const failed: string[] = []
+
+    for (const fileId of fileIds) {
+      const existingFile = await getWorkspaceFile(workspaceId, fileId)
+      if (!existingFile) {
+        failed.push(fileId)
+        continue
+      }
+
+      assertServerToolNotAborted(context)
+      await deleteWorkspaceFile(workspaceId, fileId)
+      deleted.push(existingFile.name)
+
+      logger.info('File deleted via delete_file', {
+        fileId,
+        name: existingFile.name,
+        userId: context.userId,
+      })
+    }
+
+    const parts: string[] = []
+    if (deleted.length > 0) parts.push(`Deleted: ${deleted.join(', ')}`)
+    if (failed.length > 0) parts.push(`Not found: ${failed.join(', ')}`)
+
+    return {
+      success: deleted.length > 0,
+      message: parts.join('. '),
+    }
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts b/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
index 845aac805b6..dc6b0b2daba 100644
--- a/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { z } from 'zod'
+import { DownloadToWorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -116,7 +117,7 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
   DownloadToWorkspaceFileArgs,
   DownloadToWorkspaceFileResult
 > = {
-  name: 'download_to_workspace_file',
+  name: DownloadToWorkspaceFile.id,
   inputSchema: DownloadToWorkspaceFileArgsSchema,
   outputSchema: DownloadToWorkspaceFileResultSchema,
 
@@ -124,7 +125,8 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
     params: DownloadToWorkspaceFileArgs,
     context?: ServerToolContext
   ): Promise<DownloadToWorkspaceFileResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       throw new Error('Authentication required')
@@ -176,7 +178,7 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
         mimeType
       )
 
-      reqLogger.info('Downloaded remote file to workspace', {
+      logger.info('Downloaded remote file to workspace', {
         sourceUrl: params.url,
         fileId: uploaded.id,
         fileName: uploaded.name,
@@ -193,7 +195,7 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : 'Unknown error'
-      reqLogger.error('Failed to download file to workspace', {
+      logger.error('Failed to download file to workspace', {
         url: params.url,
         error: msg,
       })
diff --git a/apps/sim/lib/copilot/tools/server/files/edit-content.ts b/apps/sim/lib/copilot/tools/server/files/edit-content.ts
new file mode 100644
index 00000000000..114c0ae7ef7
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/edit-content.ts
@@ -0,0 +1,292 @@
+import { createLogger } from '@sim/logger'
+import {
+  assertServerToolNotAborted,
+  type BaseServerTool,
+  type ServerToolContext,
+} from '@/lib/copilot/tools/server/base-tool'
+import {
+  generateDocxFromCode,
+  generatePdfFromCode,
+  generatePptxFromCode,
+} from '@/lib/execution/doc-vm'
+import { updateWorkspaceFileContent } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { consumeLatestFileIntent } from './file-intent-store'
+import { inferContentType } from './workspace-file'
+
+const logger = createLogger('EditContentServerTool')
+
+type EditContentArgs = {
+  content: string
+}
+
+type EditContentResult = {
+  success: boolean
+  message: string
+  data?: Record<string, unknown>
+}
+
+function getDocumentFormatInfo(fileName: string): {
+  isDoc: boolean
+  formatName?: string
+  sourceMime?: string
+  generator?: (code: string, workspaceId: string, signal?: AbortSignal) => Promise<Buffer>
+} {
+  const lowerName = fileName.toLowerCase()
+  if (lowerName.endsWith('.pptx')) {
+    return {
+      isDoc: true,
+      formatName: 'PPTX',
+      sourceMime: 'text/x-pptxgenjs',
+      generator: generatePptxFromCode,
+    }
+  }
+  if (lowerName.endsWith('.docx')) {
+    return {
+      isDoc: true,
+      formatName: 'DOCX',
+      sourceMime: 'text/x-docxjs',
+      generator: generateDocxFromCode,
+    }
+  }
+  if (lowerName.endsWith('.pdf')) {
+    return {
+      isDoc: true,
+      formatName: 'PDF',
+      sourceMime: 'text/x-pdflibjs',
+      generator: generatePdfFromCode,
+    }
+  }
+  return { isDoc: false }
+}
+
+export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentResult> = {
+  name: 'edit_content',
+  async execute(params: EditContentArgs, context?: ServerToolContext): Promise<EditContentResult> {
+    if (!context?.userId) {
+      logger.error('Unauthorized attempt to use edit_content')
+      throw new Error('Authentication required')
+    }
+
+    const workspaceId = context.workspaceId
+    if (!workspaceId) {
+      return { success: false, message: 'Workspace ID is required' }
+    }
+
+    const raw = params as Record<string, unknown>
+    const nested = raw.args as Record<string, unknown> | undefined
+    const content =
+      typeof params.content === 'string'
+        ? params.content
+        : typeof nested?.content === 'string'
+          ? (nested.content as string)
+          : undefined
+
+    if (content === undefined) {
+      return { success: false, message: 'content is required for edit_content' }
+    }
+
+    const intent = await consumeLatestFileIntent(workspaceId, {
+      chatId: context.chatId,
+      messageId: context.messageId,
+    })
+    if (!intent) {
+      return {
+        success: false,
+        message:
+          'No workspace_file context found. Call workspace_file first, wait for it to succeed, then call edit_content in the next step. Do not emit edit_content in parallel or in the same batch as workspace_file.',
+      }
+    }
+
+    try {
+      const { operation, fileRecord } = intent
+      const docInfo = getDocumentFormatInfo(fileRecord.name)
+
+      let finalContent: string
+      switch (operation) {
+        case 'append': {
+          const existing = intent.existingContent ?? ''
+          finalContent = docInfo.isDoc
+            ? existing
+              ? `${existing}\n{\n${content}\n}`
+              : content
+            : existing
+              ? `${existing}\n${content}`
+              : content
+          break
+        }
+        case 'update': {
+          finalContent = content
+          break
+        }
+        case 'patch': {
+          const existing = intent.existingContent ?? ''
+          if (!intent.edit) {
+            return { success: false, message: 'Patch intent missing edit metadata' }
+          }
+
+          if (intent.edit.strategy === 'search_replace') {
+            const search = intent.edit.search!
+            const firstIdx = existing.indexOf(search)
+            if (firstIdx === -1) {
+              return {
+                success: false,
+                message: `Patch failed: search string not found in file "${fileRecord.name}"`,
+              }
+            }
+            finalContent = intent.edit.replaceAll
+              ? existing.split(search).join(content)
+              : existing.slice(0, firstIdx) + content + existing.slice(firstIdx + search.length)
+          } else if (intent.edit.strategy === 'anchored') {
+            const lines = existing.split('\n')
+            const defaultOccurrence = intent.edit.occurrence ?? 1
+
+            const findAnchorLine = (
+              anchor: string,
+              occurrence = defaultOccurrence,
+              afterIndex = -1
+            ): { index: number; error?: string } => {
+              const trimmed = anchor.trim()
+              let count = 0
+              for (let i = afterIndex + 1; i < lines.length; i++) {
+                if (lines[i].trim() === trimmed) {
+                  count++
+                  if (count === occurrence) return { index: i }
+                }
+              }
+              if (count === 0) {
+                return {
+                  index: -1,
+                  error: `Anchor line not found in "${fileRecord.name}": "${anchor.slice(0, 100)}"`,
+                }
+              }
+              return {
+                index: -1,
+                error: `Anchor line occurrence ${occurrence} not found (only ${count} match${count > 1 ? 'es' : ''}) in "${fileRecord.name}": "${anchor.slice(0, 100)}"`,
+              }
+            }
+
+            if (intent.edit.mode === 'replace_between') {
+              if (!intent.edit.before_anchor || !intent.edit.after_anchor) {
+                return {
+                  success: false,
+                  message: 'replace_between requires before_anchor and after_anchor',
+                }
+              }
+              const before = findAnchorLine(intent.edit.before_anchor)
+              if (before.error) return { success: false, message: `Patch failed: ${before.error}` }
+              const after = findAnchorLine(
+                intent.edit.after_anchor,
+                defaultOccurrence,
+                before.index
+              )
+              if (after.error) return { success: false, message: `Patch failed: ${after.error}` }
+              if (after.index <= before.index) {
+                return {
+                  success: false,
+                  message: 'Patch failed: after_anchor must appear after before_anchor in the file',
+                }
+              }
+              const newLines = [
+                ...lines.slice(0, before.index + 1),
+                ...content.split('\n'),
+                ...lines.slice(after.index),
+              ]
+              finalContent = newLines.join('\n')
+            } else if (intent.edit.mode === 'insert_after') {
+              if (!intent.edit.anchor) {
+                return { success: false, message: 'insert_after requires anchor' }
+              }
+              const found = findAnchorLine(intent.edit.anchor)
+              if (found.error) return { success: false, message: `Patch failed: ${found.error}` }
+              const newLines = [
+                ...lines.slice(0, found.index + 1),
+                ...content.split('\n'),
+                ...lines.slice(found.index + 1),
+              ]
+              finalContent = newLines.join('\n')
+            } else if (intent.edit.mode === 'delete_between') {
+              if (!intent.edit.start_anchor || !intent.edit.end_anchor) {
+                return {
+                  success: false,
+                  message: 'delete_between requires start_anchor and end_anchor',
+                }
+              }
+              const start = findAnchorLine(intent.edit.start_anchor)
+              if (start.error) return { success: false, message: `Patch failed: ${start.error}` }
+              const end = findAnchorLine(intent.edit.end_anchor, defaultOccurrence, start.index)
+              if (end.error) return { success: false, message: `Patch failed: ${end.error}` }
+              if (end.index <= start.index) {
+                return {
+                  success: false,
+                  message: 'Patch failed: end_anchor must appear after start_anchor in the file',
+                }
+              }
+              const newLines = [...lines.slice(0, start.index), ...lines.slice(end.index)]
+              finalContent = newLines.join('\n')
+            } else {
+              return {
+                success: false,
+                message: `Unknown anchored patch mode: "${intent.edit.mode}"`,
+              }
+            }
+          } else {
+            return { success: false, message: `Unknown patch strategy: "${intent.edit.strategy}"` }
+          }
+          break
+        }
+        default:
+          return { success: false, message: `Unsupported operation in intent: ${operation}` }
+      }
+
+      if (docInfo.isDoc) {
+        try {
+          await docInfo.generator!(finalContent, workspaceId)
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          return {
+            success: false,
+            message: `${docInfo.formatName} generation failed: ${msg}. Fix the content and retry.`,
+          }
+        }
+      }
+
+      const fileBuffer = Buffer.from(finalContent, 'utf-8')
+      assertServerToolNotAborted(context)
+      const mime = docInfo.sourceMime || inferContentType(fileRecord.name, intent.contentType)
+      await updateWorkspaceFileContent(workspaceId, intent.fileId, context.userId, fileBuffer, mime)
+
+      const verb =
+        operation === 'append' ? 'appended to' : operation === 'update' ? 'updated' : 'patched'
+      logger.info(`Workspace file ${verb} via copilot (edit_content)`, {
+        fileId: intent.fileId,
+        name: fileRecord.name,
+        operation,
+        size: fileBuffer.length,
+        userId: context.userId,
+      })
+
+      return {
+        success: true,
+        message: `File "${fileRecord.name}" ${verb} successfully (${fileBuffer.length} bytes)`,
+        data: {
+          id: intent.fileId,
+          name: fileRecord.name,
+          size: fileBuffer.length,
+          contentType: mime,
+        },
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred'
+      logger.error('Error in edit_content tool', {
+        operation: intent.operation,
+        fileId: intent.fileId,
+        error: errorMessage,
+        userId: context.userId,
+      })
+      return {
+        success: false,
+        message: `Failed to apply content: ${errorMessage}`,
+      }
+    }
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/file-intent-store.ts b/apps/sim/lib/copilot/tools/server/files/file-intent-store.ts
new file mode 100644
index 00000000000..33963b4123c
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/file-intent-store.ts
@@ -0,0 +1,289 @@
+import { createLogger } from '@sim/logger'
+import { getRedisClient } from '@/lib/core/config/redis'
+import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+export type PendingFileIntent = {
+  operation: 'append' | 'update' | 'patch'
+  fileId: string
+  workspaceId: string
+  userId: string
+  chatId?: string
+  messageId?: string
+  fileRecord: WorkspaceFileRecord
+  existingContent?: string
+  edit?: {
+    strategy: string
+    search?: string
+    replaceAll?: boolean
+    mode?: string
+    occurrence?: number
+    before_anchor?: string
+    after_anchor?: string
+    anchor?: string
+    start_anchor?: string
+    end_anchor?: string
+  }
+  contentType?: string
+  title?: string
+  createdAt: number
+}
+
+export type FileIntentScope = {
+  chatId?: string
+  messageId?: string
+}
+
+const logger = createLogger('FileIntentStore')
+
+const INTENT_TTL_MS = 60 * 60 * 1000
+const INTENT_TTL_SECONDS = INTENT_TTL_MS / 1000
+const REDIS_KEY_PREFIX = 'mothership_file_intent:'
+const RETRY_DELAYS_MS = [0, 50, 150] as const
+const memoryStore = new Map<string, PendingFileIntent>()
+
+function buildKey(workspaceId: string, fileId: string): string {
+  return `${workspaceId}:${fileId}`
+}
+
+function getWorkspaceRedisKey(workspaceId: string): string {
+  return `${REDIS_KEY_PREFIX}${workspaceId}`
+}
+
+function scopeMatches(intent: PendingFileIntent, scope?: FileIntentScope): boolean {
+  return intent.chatId === scope?.chatId && intent.messageId === scope?.messageId
+}
+
+function buildScopedField(fileId: string, scope?: FileIntentScope): string {
+  return `${scope?.chatId ?? ''}:${scope?.messageId ?? ''}:${fileId}`
+}
+
+function cleanupStale(): void {
+  const now = Date.now()
+  for (const [key, intent] of memoryStore) {
+    if (now - intent.createdAt > INTENT_TTL_MS) {
+      memoryStore.delete(key)
+    }
+  }
+}
+
+async function withRedisRetry<T>(
+  operation: string,
+  workspaceId: string,
+  work: (redis: NonNullable<ReturnType<typeof getRedisClient>>) => Promise<T>
+): Promise<T> {
+  const redis = getRedisClient()
+  if (!redis) {
+    throw new Error('Redis client unavailable')
+  }
+
+  let lastError: unknown
+  for (let attempt = 0; attempt < RETRY_DELAYS_MS.length; attempt++) {
+    const delay = RETRY_DELAYS_MS[attempt]
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay))
+    }
+
+    try {
+      return await work(redis)
+    } catch (error) {
+      lastError = error
+      logger.warn('Redis file intent operation failed', {
+        operation,
+        workspaceId,
+        attempt: attempt + 1,
+        error: error instanceof Error ? error.message : String(error),
+      })
+    }
+  }
+
+  throw lastError instanceof Error ? lastError : new Error(`${operation} failed`)
+}
+
+function isStale(intent: PendingFileIntent): boolean {
+  return Date.now() - intent.createdAt > INTENT_TTL_MS
+}
+
+function parseIntent(raw: string | null | undefined): PendingFileIntent | undefined {
+  if (!raw) return undefined
+  try {
+    const parsed = JSON.parse(raw) as PendingFileIntent
+    return isStale(parsed) ? undefined : parsed
+  } catch (error) {
+    logger.warn('Failed to parse file intent', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return undefined
+  }
+}
+
+export async function storeFileIntent(
+  workspaceId: string,
+  fileId: string,
+  intent: PendingFileIntent
+): Promise<void> {
+  const redis = getRedisClient()
+  if (!redis) {
+    cleanupStale()
+    memoryStore.set(buildKey(workspaceId, buildScopedField(fileId, intent)), intent)
+    return
+  }
+
+  await withRedisRetry('store_file_intent', workspaceId, async (client) => {
+    const key = getWorkspaceRedisKey(workspaceId)
+    const pipeline = client.pipeline()
+    pipeline.hset(key, buildScopedField(fileId, intent), JSON.stringify(intent))
+    pipeline.expire(key, INTENT_TTL_SECONDS)
+    await pipeline.exec()
+  })
+}
+
+export async function consumeFileIntent(
+  workspaceId: string,
+  fileId: string,
+  scope?: FileIntentScope
+): Promise<PendingFileIntent | undefined> {
+  const redis = getRedisClient()
+  if (!redis) {
+    const key = buildKey(workspaceId, buildScopedField(fileId, scope))
+    const intent = memoryStore.get(key)
+    if (intent) {
+      memoryStore.delete(key)
+    }
+    return intent
+  }
+
+  const raw = await withRedisRetry('consume_file_intent', workspaceId, async (client) => {
+    const key = getWorkspaceRedisKey(workspaceId)
+    const field = buildScopedField(fileId, scope)
+    const value = await client.hget(key, field)
+    if (value !== null) {
+      await client.hdel(key, field)
+    }
+    return value
+  })
+  return parseIntent(raw)
+}
+
+export async function peekFileIntent(
+  workspaceId: string,
+  fileId: string,
+  scope?: FileIntentScope
+): Promise<PendingFileIntent | undefined> {
+  const redis = getRedisClient()
+  if (!redis) {
+    cleanupStale()
+    return memoryStore.get(buildKey(workspaceId, buildScopedField(fileId, scope)))
+  }
+
+  const raw = await withRedisRetry('peek_file_intent', workspaceId, async (client) => {
+    const key = getWorkspaceRedisKey(workspaceId)
+    return client.hget(key, buildScopedField(fileId, scope))
+  })
+  const intent = parseIntent(raw)
+  if (!intent && raw !== null) {
+    await withRedisRetry('clear_stale_file_intent', workspaceId, async (client) => {
+      await client.hdel(getWorkspaceRedisKey(workspaceId), buildScopedField(fileId, scope))
+    })
+  }
+  return intent
+}
+
+export async function consumeLatestFileIntent(
+  workspaceId: string,
+  scope?: FileIntentScope
+): Promise<PendingFileIntent | undefined> {
+  const redis = getRedisClient()
+  if (!redis) {
+    cleanupStale()
+    let latest: PendingFileIntent | undefined
+    let latestKey: string | undefined
+    for (const [key, intent] of memoryStore) {
+      if (intent.workspaceId === workspaceId && scopeMatches(intent, scope)) {
+        if (!latest || intent.createdAt > latest.createdAt) {
+          latest = intent
+          latestKey = key
+        }
+      }
+    }
+    if (latestKey) {
+      memoryStore.delete(latestKey)
+    }
+    return latest
+  }
+
+  const entries = await withRedisRetry('read_workspace_file_intents', workspaceId, async (client) =>
+    client.hgetall(getWorkspaceRedisKey(workspaceId))
+  )
+  let latest: PendingFileIntent | undefined
+  let latestField: string | undefined
+  const staleFields: string[] = []
+  for (const [field, raw] of Object.entries(entries)) {
+    const parsed = parseIntent(raw)
+    if (!parsed) {
+      staleFields.push(field)
+      continue
+    }
+    if (!scopeMatches(parsed, scope)) {
+      continue
+    }
+    if (!latest || parsed.createdAt > latest.createdAt) {
+      latest = parsed
+      latestField = field
+    }
+  }
+
+  const fieldsToDelete = latestField ? [...staleFields, latestField] : staleFields
+  if (fieldsToDelete.length > 0) {
+    await withRedisRetry('delete_workspace_file_intents', workspaceId, async (client) => {
+      await client.hdel(getWorkspaceRedisKey(workspaceId), ...fieldsToDelete)
+    })
+  }
+  return latest
+}
+
+export async function clearIntentsForWorkspace(
+  workspaceId: string,
+  scope?: FileIntentScope
+): Promise<number> {
+  const redis = getRedisClient()
+  if (!redis) {
+    let cleared = 0
+    for (const [key, intent] of memoryStore) {
+      if (intent.workspaceId === workspaceId && (!scope || scopeMatches(intent, scope))) {
+        memoryStore.delete(key)
+        cleared++
+      }
+    }
+    return cleared
+  }
+
+  const key = getWorkspaceRedisKey(workspaceId)
+  if (!scope) {
+    const count = await withRedisRetry(
+      'count_workspace_file_intents',
+      workspaceId,
+      async (client) => client.hlen(key)
+    )
+    await withRedisRetry('clear_workspace_file_intents', workspaceId, async (client) => {
+      await client.del(key)
+    })
+    return count
+  }
+
+  const entries = await withRedisRetry('read_workspace_file_intents', workspaceId, async (client) =>
+    client.hgetall(key)
+  )
+  const fieldsToDelete: string[] = []
+  for (const [field, raw] of Object.entries(entries)) {
+    const parsed = parseIntent(raw)
+    if (parsed && scopeMatches(parsed, scope)) {
+      fieldsToDelete.push(field)
+    }
+  }
+  if (fieldsToDelete.length > 0) {
+    await withRedisRetry('clear_scoped_file_intents', workspaceId, async (client) => {
+      await client.hdel(key, ...fieldsToDelete)
+    })
+  }
+  return fieldsToDelete.length
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/file-preview.test.ts b/apps/sim/lib/copilot/tools/server/files/file-preview.test.ts
new file mode 100644
index 00000000000..52a033c1b62
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/file-preview.test.ts
@@ -0,0 +1,79 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { buildFilePreviewText } from '@/lib/copilot/tools/server/files/file-preview'
+
+describe('buildFilePreviewText', () => {
+  it('returns the full streamed content for update previews', () => {
+    expect(
+      buildFilePreviewText({
+        operation: 'update',
+        streamedContent: '',
+      })
+    ).toBe('')
+
+    expect(
+      buildFilePreviewText({
+        operation: 'update',
+        streamedContent: 'updated body',
+      })
+    ).toBe('updated body')
+  })
+
+  it('builds append previews from the existing file content', () => {
+    expect(
+      buildFilePreviewText({
+        operation: 'append',
+        existingContent: 'line one',
+        streamedContent: 'line two',
+      })
+    ).toBe('line one\nline two')
+  })
+
+  it('applies anchored replace_between previews', () => {
+    expect(
+      buildFilePreviewText({
+        operation: 'patch',
+        existingContent: ['# Title', 'before', 'after', 'footer'].join('\n'),
+        streamedContent: 'replacement',
+        edit: {
+          strategy: 'anchored',
+          mode: 'replace_between',
+          before_anchor: '# Title',
+          after_anchor: 'after',
+        },
+      })
+    ).toBe(['# Title', 'replacement', 'after', 'footer'].join('\n'))
+  })
+
+  it('applies delete_between previews without streamed replacement text', () => {
+    expect(
+      buildFilePreviewText({
+        operation: 'patch',
+        existingContent: ['keep', 'start', 'remove me', 'end', 'keep too'].join('\n'),
+        streamedContent: '',
+        edit: {
+          strategy: 'anchored',
+          mode: 'delete_between',
+          start_anchor: 'start',
+          end_anchor: 'end',
+        },
+      })
+    ).toBe(['keep', 'end', 'keep too'].join('\n'))
+  })
+
+  it('applies search_replace previews', () => {
+    expect(
+      buildFilePreviewText({
+        operation: 'patch',
+        existingContent: 'hello world',
+        streamedContent: 'sim',
+        edit: {
+          strategy: 'search_replace',
+          search: 'world',
+        },
+      })
+    ).toBe('hello sim')
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/files/file-preview.ts b/apps/sim/lib/copilot/tools/server/files/file-preview.ts
new file mode 100644
index 00000000000..fd783321b3f
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/file-preview.ts
@@ -0,0 +1,192 @@
+import { createLogger } from '@sim/logger'
+import {
+  downloadWorkspaceFile,
+  getWorkspaceFile,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const logger = createLogger('CopilotFilePreview')
+
+type FilePreviewEdit = {
+  strategy?: string
+  search?: string
+  replaceAll?: boolean
+  mode?: string
+  occurrence?: number
+  before_anchor?: string
+  after_anchor?: string
+  anchor?: string
+  start_anchor?: string
+  end_anchor?: string
+}
+
+interface BuildFilePreviewTextOptions {
+  operation: 'create' | 'append' | 'update' | 'patch'
+  streamedContent: string
+  existingContent?: string
+  edit?: Record<string, unknown>
+}
+
+function findAnchorIndex(lines: string[], anchor: string, occurrence = 1, afterIndex = -1): number {
+  const trimmed = anchor.trim()
+  let count = 0
+  for (let i = afterIndex + 1; i < lines.length; i++) {
+    if (lines[i].trim() === trimmed) {
+      count++
+      if (count === occurrence) return i
+    }
+  }
+  return -1
+}
+
+function extractPatchPreview(
+  streamedContent: string,
+  existingContent: string,
+  edit?: Record<string, unknown>
+): string | undefined {
+  const strategy = typeof edit?.strategy === 'string' ? edit.strategy : undefined
+  const lines = existingContent.split('\n')
+  const occurrence =
+    typeof edit?.occurrence === 'number' && Number.isFinite(edit.occurrence) ? edit.occurrence : 1
+
+  if (strategy === 'search_replace') {
+    const search = typeof edit?.search === 'string' ? edit.search : ''
+    if (!search) return undefined
+    if (edit?.replaceAll === true) {
+      return existingContent.split(search).join(streamedContent)
+    }
+    const firstIdx = existingContent.indexOf(search)
+    if (firstIdx === -1) return undefined
+    return (
+      existingContent.slice(0, firstIdx) +
+      streamedContent +
+      existingContent.slice(firstIdx + search.length)
+    )
+  }
+
+  const mode = typeof edit?.mode === 'string' ? edit.mode : undefined
+  if (!mode) return undefined
+
+  if (mode === 'replace_between') {
+    const beforeAnchor = typeof edit?.before_anchor === 'string' ? edit.before_anchor : undefined
+    const afterAnchor = typeof edit?.after_anchor === 'string' ? edit.after_anchor : undefined
+    if (!beforeAnchor || !afterAnchor) return undefined
+
+    const beforeIdx = findAnchorIndex(lines, beforeAnchor, occurrence)
+    const afterIdx = findAnchorIndex(lines, afterAnchor, occurrence, beforeIdx)
+    if (beforeIdx === -1 || afterIdx === -1 || afterIdx <= beforeIdx) return undefined
+
+    const spliced = [
+      ...lines.slice(0, beforeIdx + 1),
+      ...(streamedContent.length > 0 ? streamedContent.split('\n') : []),
+      ...lines.slice(afterIdx),
+    ]
+    return spliced.join('\n')
+  }
+
+  if (mode === 'insert_after') {
+    const anchor = typeof edit?.anchor === 'string' ? edit.anchor : undefined
+    if (!anchor) return undefined
+
+    const anchorIdx = findAnchorIndex(lines, anchor, occurrence)
+    if (anchorIdx === -1) return undefined
+
+    const spliced = [
+      ...lines.slice(0, anchorIdx + 1),
+      ...(streamedContent.length > 0 ? streamedContent.split('\n') : []),
+      ...lines.slice(anchorIdx + 1),
+    ]
+    return spliced.join('\n')
+  }
+
+  if (mode === 'delete_between') {
+    const startAnchor = typeof edit?.start_anchor === 'string' ? edit.start_anchor : undefined
+    const endAnchor = typeof edit?.end_anchor === 'string' ? edit.end_anchor : undefined
+    if (!startAnchor || !endAnchor) return undefined
+
+    const startIdx = findAnchorIndex(lines, startAnchor, occurrence)
+    const endIdx = findAnchorIndex(lines, endAnchor, occurrence, startIdx)
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return undefined
+
+    const spliced = [...lines.slice(0, startIdx), ...lines.slice(endIdx)]
+    return spliced.join('\n')
+  }
+
+  return undefined
+}
+
+function shouldApplyPatchPreview(streamedContent: string, edit?: Record<string, unknown>): boolean {
+  const strategy = typeof edit?.strategy === 'string' ? edit.strategy : undefined
+  const mode = typeof edit?.mode === 'string' ? edit.mode : undefined
+
+  if (strategy === 'anchored' && mode === 'delete_between') {
+    return true
+  }
+
+  return streamedContent.length > 0
+}
+
+function buildAppendPreview(existingContent: string, incomingContent: string): string {
+  if (incomingContent.length === 0) return existingContent
+  if (existingContent.length === 0) return incomingContent
+  return `${existingContent}\n${incomingContent}`
+}
+
+/**
+ * Reads the current UTF-8 text of a workspace file for streaming previews.
+ *
+ * Preview runs in the SSE loop on `workspace_file` **call** events, which are
+ * processed **before** the async tool executor persists {@link storeFileIntent}.
+ * Loading the base here avoids a race where `edit_content` `args_delta` arrives
+ * before Redis holds `existingContent`, which would make append previews look like
+ * full-file replacement until the intent landed.
+ */
+export async function loadWorkspaceFileTextForPreview(
+  workspaceId: string,
+  fileId: string
+): Promise<string | undefined> {
+  try {
+    const record = await getWorkspaceFile(workspaceId, fileId)
+    if (!record) return undefined
+    const buffer = await downloadWorkspaceFile(record)
+    return buffer.toString('utf-8')
+  } catch (error) {
+    logger.warn('Failed to load workspace file text for preview', {
+      workspaceId,
+      fileId,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return undefined
+  }
+}
+
+export function buildFilePreviewText({
+  operation,
+  streamedContent,
+  existingContent,
+  edit,
+}: BuildFilePreviewTextOptions): string | undefined {
+  if (operation === 'update') {
+    return streamedContent
+  }
+
+  if (operation === 'create') {
+    return streamedContent
+  }
+
+  if (operation === 'append') {
+    if (existingContent !== undefined) {
+      return buildAppendPreview(existingContent, streamedContent)
+    }
+    return streamedContent
+  }
+
+  if (existingContent === undefined) {
+    return undefined
+  }
+
+  if (!shouldApplyPatchPreview(streamedContent, edit)) {
+    return undefined
+  }
+
+  return extractPatchPreview(streamedContent, existingContent, edit)
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/rename-file.ts b/apps/sim/lib/copilot/tools/server/files/rename-file.ts
new file mode 100644
index 00000000000..bfc7b02be16
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/rename-file.ts
@@ -0,0 +1,75 @@
+import { createLogger } from '@sim/logger'
+import { RenameFile } from '@/lib/copilot/generated/tool-catalog-v1'
+import {
+  assertServerToolNotAborted,
+  type BaseServerTool,
+  type ServerToolContext,
+} from '@/lib/copilot/tools/server/base-tool'
+import {
+  getWorkspaceFile,
+  renameWorkspaceFile,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { validateFlatWorkspaceFileName } from './workspace-file'
+
+const logger = createLogger('RenameFileServerTool')
+
+interface RenameFileArgs {
+  fileId: string
+  newName: string
+  args?: Record<string, unknown>
+}
+
+interface RenameFileResult {
+  success: boolean
+  message: string
+  data?: {
+    id: string
+    name: string
+  }
+}
+
+export const renameFileServerTool: BaseServerTool<RenameFileArgs, RenameFileResult> = {
+  name: RenameFile.id,
+  async execute(params: RenameFileArgs, context?: ServerToolContext): Promise<RenameFileResult> {
+    if (!context?.userId) {
+      throw new Error('Authentication required')
+    }
+    const workspaceId = context.workspaceId
+    if (!workspaceId) {
+      return { success: false, message: 'Workspace ID is required' }
+    }
+
+    const nested = params.args
+    const fileId = params.fileId || (nested?.fileId as string) || ''
+    const newName = params.newName || (nested?.newName as string) || ''
+
+    if (!fileId) return { success: false, message: 'fileId is required' }
+
+    const nameError = validateFlatWorkspaceFileName(newName)
+    if (nameError) return { success: false, message: nameError }
+
+    const existingFile = await getWorkspaceFile(workspaceId, fileId)
+    if (!existingFile) {
+      return { success: false, message: `File with ID "${fileId}" not found` }
+    }
+
+    assertServerToolNotAborted(context)
+    await renameWorkspaceFile(workspaceId, fileId, newName)
+
+    logger.info('File renamed via rename_file', {
+      fileId,
+      oldName: existingFile.name,
+      newName,
+      userId: context.userId,
+    })
+
+    return {
+      success: true,
+      message: `File renamed from "${existingFile.name}" to "${newName}"`,
+      data: {
+        id: fileId,
+        name: newName,
+      },
+    }
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/workspace-file.ts b/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
index 76a0d1fdafe..a9ae344192c 100644
--- a/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
@@ -1,24 +1,82 @@
 import { createLogger } from '@sim/logger'
+import { WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
-import type { WorkspaceFileArgs, WorkspaceFileResult } from '@/lib/copilot/tools/shared/schemas'
-import { generatePptxFromCode } from '@/lib/execution/pptx-vm'
+import {
+  generateDocxFromCode,
+  generatePdfFromCode,
+  generatePptxFromCode,
+} from '@/lib/execution/doc-vm'
 import {
   deleteWorkspaceFile,
   downloadWorkspaceFile as downloadWsFile,
   getWorkspaceFile,
+  getWorkspaceFileByName,
   renameWorkspaceFile,
-  updateWorkspaceFileContent,
   uploadWorkspaceFile,
 } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { storeFileIntent } from './file-intent-store'
 
 const logger = createLogger('WorkspaceFileServerTool')
 
 const PPTX_MIME = 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+const DOCX_MIME = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+const PDF_MIME = 'application/pdf'
 const PPTX_SOURCE_MIME = 'text/x-pptxgenjs'
+const DOCX_SOURCE_MIME = 'text/x-docxjs'
+const PDF_SOURCE_MIME = 'text/x-pdflibjs'
+
+type WorkspaceFileOperation = 'create' | 'append' | 'update' | 'delete' | 'rename' | 'patch'
+
+type WorkspaceFileTarget =
+  | {
+      kind: 'new_file'
+      fileName: string
+      fileId?: string
+    }
+  | {
+      kind: 'file_id'
+      fileId: string
+      fileName?: string
+    }
+
+type WorkspaceFileEdit =
+  | {
+      strategy: 'search_replace'
+      search: string
+      replace: string
+      replaceAll?: boolean
+    }
+  | {
+      strategy: 'anchored'
+      mode: 'replace_between' | 'insert_after' | 'delete_between'
+      occurrence?: number
+      before_anchor?: string
+      after_anchor?: string
+      start_anchor?: string
+      end_anchor?: string
+      anchor?: string
+      content?: string
+    }
+
+type WorkspaceFileArgs = {
+  operation: WorkspaceFileOperation
+  target?: WorkspaceFileTarget
+  title?: string
+  content?: string
+  contentType?: string
+  newName?: string
+  edit?: WorkspaceFileEdit
+}
+
+type WorkspaceFileResult = {
+  success: boolean
+  message: string
+  data?: Record<string, unknown>
+}
 
 const EXT_TO_MIME: Record<string, string> = {
   '.txt': 'text/plain',
@@ -27,15 +85,17 @@ const EXT_TO_MIME: Record<string, string> = {
   '.json': 'application/json',
   '.csv': 'text/csv',
   '.pptx': PPTX_MIME,
+  '.docx': DOCX_MIME,
+  '.pdf': PDF_MIME,
 }
 
-function inferContentType(fileName: string, explicitType?: string): string {
+export function inferContentType(fileName: string, explicitType?: string): string {
   if (explicitType) return explicitType
   const ext = fileName.slice(fileName.lastIndexOf('.')).toLowerCase()
   return EXT_TO_MIME[ext] || 'text/plain'
 }
 
-function validateFlatWorkspaceFileName(fileName: string): string | null {
+export function validateFlatWorkspaceFileName(fileName: string): string | null {
   const trimmed = fileName.trim()
   if (!trimmed) return 'File name cannot be empty'
   if (trimmed.includes('/')) {
@@ -44,22 +104,72 @@ function validateFlatWorkspaceFileName(fileName: string): string | null {
   return null
 }
 
+function getDocumentFormatInfo(fileName: string): {
+  isDoc: boolean
+  formatName?: 'PPTX' | 'DOCX' | 'PDF'
+  sourceMime?: string
+  generator?: (code: string, workspaceId: string, signal?: AbortSignal) => Promise<Buffer>
+} {
+  const lowerName = fileName.toLowerCase()
+  if (lowerName.endsWith('.pptx')) {
+    return {
+      isDoc: true,
+      formatName: 'PPTX',
+      sourceMime: PPTX_SOURCE_MIME,
+      generator: generatePptxFromCode,
+    }
+  }
+  if (lowerName.endsWith('.docx')) {
+    return {
+      isDoc: true,
+      formatName: 'DOCX',
+      sourceMime: DOCX_SOURCE_MIME,
+      generator: generateDocxFromCode,
+    }
+  }
+  if (lowerName.endsWith('.pdf')) {
+    return {
+      isDoc: true,
+      formatName: 'PDF',
+      sourceMime: PDF_SOURCE_MIME,
+      generator: generatePdfFromCode,
+    }
+  }
+  return { isDoc: false }
+}
+
 export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, WorkspaceFileResult> = {
-  name: 'workspace_file',
+  name: WorkspaceFile.id,
   async execute(
     params: WorkspaceFileArgs,
     context?: ServerToolContext
   ): Promise<WorkspaceFileResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
-      reqLogger.error('Unauthorized attempt to access workspace files')
+      logger.error('Unauthorized attempt to access workspace files')
       throw new Error('Authentication required')
     }
 
-    const { operation, args = {} } = params
-    const workspaceId =
-      context.workspaceId || ((args as Record<string, unknown>).workspaceId as string | undefined)
+    const raw = params as Record<string, unknown>
+    const nested = raw.args as Record<string, unknown> | undefined
+    const normalized: WorkspaceFileArgs =
+      params.operation && params.target
+        ? params
+        : nested && typeof nested === 'object'
+          ? {
+              operation: (nested.operation ?? raw.operation) as WorkspaceFileOperation,
+              target: (nested.target ?? raw.target) as WorkspaceFileTarget | undefined,
+              title: (nested.title ?? raw.title) as string | undefined,
+              content: (nested.content ?? raw.content) as string | undefined,
+              contentType: (nested.contentType ?? raw.contentType) as string | undefined,
+              newName: (nested.newName ?? raw.newName) as string | undefined,
+              edit: (nested.edit ?? raw.edit) as WorkspaceFileEdit | undefined,
+            }
+          : params
+    const { operation } = normalized
+    const workspaceId = context.workspaceId
 
     if (!workspaceId) {
       return { success: false, message: 'Workspace ID is required' }
@@ -67,44 +177,42 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
 
     try {
       switch (operation) {
-        case 'write': {
-          const fileName = (args as Record<string, unknown>).fileName as string | undefined
-          const content = (args as Record<string, unknown>).content as string | undefined
-          const explicitType = (args as Record<string, unknown>).contentType as string | undefined
-
-          if (!fileName) {
-            return { success: false, message: 'fileName is required for write operation' }
-          }
-          if (content === undefined || content === null) {
-            return { success: false, message: 'content is required for write operation' }
+        case 'create': {
+          const target = normalized.target
+          if (!target || target.kind !== 'new_file') {
+            return {
+              success: false,
+              message: 'create requires target.kind=new_file with target.fileName',
+            }
           }
+
+          const fileName = target.fileName
+          const content = normalized.content ?? ''
+          const explicitType = normalized.contentType
           const fileNameValidationError = validateFlatWorkspaceFileName(fileName)
-          if (fileNameValidationError) {
-            return { success: false, message: fileNameValidationError }
-          }
+          if (fileNameValidationError) return { success: false, message: fileNameValidationError }
 
-          const isPptx = fileName.toLowerCase().endsWith('.pptx')
-          let contentType: string
+          const existingFile = await getWorkspaceFileByName(workspaceId, fileName)
+          if (existingFile) {
+            return { success: false, message: `File "${fileName}" already exists` }
+          }
 
-          if (isPptx) {
-            // Validate the code compiles before storing
+          const docInfo = getDocumentFormatInfo(fileName)
+          let contentType = inferContentType(fileName, explicitType)
+          if (docInfo.isDoc) {
             try {
-              await generatePptxFromCode(content, workspaceId)
+              await docInfo.generator!(content, workspaceId)
             } catch (err) {
               const msg = err instanceof Error ? err.message : String(err)
-              reqLogger.error('PPTX code validation failed', { error: msg, fileName })
               return {
                 success: false,
-                message: `PPTX generation failed: ${msg}. Fix the pptxgenjs code and retry.`,
+                message: `${docInfo.formatName} generation failed: ${msg}. Fix the code and retry.`,
               }
             }
-            contentType = PPTX_SOURCE_MIME
-          } else {
-            contentType = inferContentType(fileName, explicitType)
+            contentType = docInfo.sourceMime!
           }
 
           const fileBuffer = Buffer.from(content, 'utf-8')
-
           assertServerToolNotAborted(context)
           const result = await uploadWorkspaceFile(
             workspaceId,
@@ -114,7 +222,7 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
             contentType
           )
 
-          reqLogger.info('Workspace file written via copilot', {
+          logger.info('Workspace file created via copilot', {
             fileId: result.id,
             name: fileName,
             size: fileBuffer.length,
@@ -135,118 +243,148 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
           }
         }
 
-        case 'update': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          const content = (args as Record<string, unknown>).content as string | undefined
+        case 'append': {
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'append requires target.kind=file_id with target.fileId',
+            }
+          }
 
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for update operation' }
+          const existingFile = await getWorkspaceFile(workspaceId, target.fileId)
+          if (!existingFile) {
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
           }
-          if (content === undefined || content === null) {
-            return { success: false, message: 'content is required for update operation' }
+          if (target.fileName && target.fileName !== existingFile.name) {
+            return {
+              success: false,
+              message: `Target mismatch: fileId "${target.fileId}" is "${existingFile.name}", not "${target.fileName}"`,
+            }
           }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
-          if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+          const currentBuffer = await downloadWsFile(existingFile)
+          await storeFileIntent(workspaceId, target.fileId, {
+            operation: 'append',
+            fileId: target.fileId,
+            workspaceId,
+            userId: context.userId,
+            chatId: context.chatId,
+            messageId: context.messageId,
+            fileRecord: existingFile,
+            existingContent: currentBuffer.toString('utf-8'),
+            contentType: normalized.contentType,
+            title: normalized.title,
+            createdAt: Date.now(),
+          })
+
+          return {
+            success: true,
+            message: withMessageId(
+              `Intent set: append to "${existingFile.name}". Wait for this success result, then call edit_content in the next step with the content to write. Do not call edit_content in parallel.`
+            ),
+            data: { id: existingFile.id, name: existingFile.name, operation: 'append' },
           }
+        }
 
-          const isPptxUpdate = fileRecord.name?.toLowerCase().endsWith('.pptx')
-          if (isPptxUpdate) {
-            try {
-              await generatePptxFromCode(content, workspaceId)
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err)
-              return {
-                success: false,
-                message: `PPTX generation failed: ${msg}. Fix the pptxgenjs code and retry.`,
-              }
+        case 'update': {
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'update requires target.kind=file_id with target.fileId',
             }
           }
 
-          const fileBuffer = Buffer.from(content, 'utf-8')
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
+          if (!fileRecord) {
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
+          }
+          if (target.fileName && target.fileName !== fileRecord.name) {
+            return {
+              success: false,
+              message: `Target mismatch: fileId "${target.fileId}" is "${fileRecord.name}", not "${target.fileName}"`,
+            }
+          }
 
-          assertServerToolNotAborted(context)
-          await updateWorkspaceFileContent(
+          await storeFileIntent(workspaceId, target.fileId, {
+            operation: 'update',
+            fileId: target.fileId,
             workspaceId,
-            fileId,
-            context.userId,
-            fileBuffer,
-            isPptxUpdate ? PPTX_SOURCE_MIME : undefined
-          )
-
-          reqLogger.info('Workspace file updated via copilot', {
-            fileId,
-            name: fileRecord.name,
-            size: fileBuffer.length,
             userId: context.userId,
+            chatId: context.chatId,
+            messageId: context.messageId,
+            fileRecord,
+            contentType: normalized.contentType,
+            title: normalized.title,
+            createdAt: Date.now(),
           })
 
           return {
             success: true,
-            message: `File "${fileRecord.name}" updated successfully (${fileBuffer.length} bytes)`,
-            data: {
-              id: fileId,
-              name: fileRecord.name,
-              size: fileBuffer.length,
-            },
+            message: withMessageId(
+              `Intent set: update "${fileRecord.name}". Wait for this success result, then call edit_content in the next step with the replacement content. Do not call edit_content in parallel.`
+            ),
+            data: { id: target.fileId, name: fileRecord.name, operation: 'update' },
           }
         }
 
         case 'rename': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          const newName = (args as Record<string, unknown>).newName as string | undefined
-
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for rename operation' }
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'rename requires target.kind=file_id with target.fileId',
+            }
           }
-          if (!newName) {
+          if (!normalized.newName) {
             return { success: false, message: 'newName is required for rename operation' }
           }
-          const fileNameValidationError = validateFlatWorkspaceFileName(newName)
-          if (fileNameValidationError) {
-            return { success: false, message: fileNameValidationError }
-          }
+          const fileNameValidationError = validateFlatWorkspaceFileName(normalized.newName)
+          if (fileNameValidationError) return { success: false, message: fileNameValidationError }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
           if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
           }
 
           const oldName = fileRecord.name
           assertServerToolNotAborted(context)
-          await renameWorkspaceFile(workspaceId, fileId, newName)
+          await renameWorkspaceFile(workspaceId, target.fileId, normalized.newName)
 
-          reqLogger.info('Workspace file renamed via copilot', {
-            fileId,
+          logger.info('Workspace file renamed via copilot', {
+            fileId: target.fileId,
             oldName,
-            newName,
+            newName: normalized.newName,
             userId: context.userId,
           })
 
           return {
             success: true,
-            message: `File renamed from "${oldName}" to "${newName}"`,
-            data: { id: fileId, name: newName },
+            message: `File renamed from "${oldName}" to "${normalized.newName}"`,
+            data: { id: target.fileId, name: normalized.newName },
           }
         }
 
         case 'delete': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for delete operation' }
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'delete requires target.kind=file_id with target.fileId',
+            }
           }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
           if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
           }
 
           assertServerToolNotAborted(context)
-          await deleteWorkspaceFile(workspaceId, fileId)
+          await deleteWorkspaceFile(workspaceId, target.fileId)
 
-          reqLogger.info('Workspace file deleted via copilot', {
-            fileId,
+          logger.info('Workspace file deleted via copilot', {
+            fileId: target.fileId,
             name: fileRecord.name,
             userId: context.userId,
           })
@@ -254,101 +392,108 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
           return {
             success: true,
             message: `File "${fileRecord.name}" deleted successfully`,
-            data: { id: fileId, name: fileRecord.name },
+            data: { id: target.fileId, name: fileRecord.name },
           }
         }
 
         case 'patch': {
-          const fileId = (args as Record<string, unknown>).fileId as string | undefined
-          const edits = (args as Record<string, unknown>).edits as
-            | { search: string; replace: string }[]
-            | undefined
-
-          if (!fileId) {
-            return { success: false, message: 'fileId is required for patch operation' }
+          const target = normalized.target
+          if (!target || target.kind !== 'file_id') {
+            return {
+              success: false,
+              message: 'patch requires target.kind=file_id with target.fileId',
+            }
           }
-          if (!edits || !Array.isArray(edits) || edits.length === 0) {
-            return { success: false, message: 'edits array is required for patch operation' }
+          if (!normalized.edit) {
+            return { success: false, message: 'edit is required for patch operation' }
           }
 
-          const fileRecord = await getWorkspaceFile(workspaceId, fileId)
+          const fileRecord = await getWorkspaceFile(workspaceId, target.fileId)
           if (!fileRecord) {
-            return { success: false, message: `File with ID "${fileId}" not found` }
+            return { success: false, message: `File with ID "${target.fileId}" not found` }
           }
 
           const currentBuffer = await downloadWsFile(fileRecord)
-          let content = currentBuffer.toString('utf-8')
+          const existingContent = currentBuffer.toString('utf-8')
 
-          for (const edit of edits) {
-            const firstIdx = content.indexOf(edit.search)
+          if (normalized.edit.strategy === 'search_replace') {
+            const search = normalized.edit.search
+            const firstIdx = existingContent.indexOf(search)
             if (firstIdx === -1) {
               return {
                 success: false,
-                message: `Patch failed: search string not found in file "${fileRecord.name}". Search: "${edit.search.slice(0, 100)}${edit.search.length > 100 ? '...' : ''}"`,
+                message: `Patch failed: search string not found in file "${fileRecord.name}". Search: "${search.slice(0, 100)}${search.length > 100 ? '...' : ''}"`,
               }
             }
-            if (content.indexOf(edit.search, firstIdx + 1) !== -1) {
+            if (
+              !normalized.edit.replaceAll &&
+              existingContent.indexOf(search, firstIdx + 1) !== -1
+            ) {
               return {
                 success: false,
-                message: `Patch failed: search string is ambiguous — found at multiple locations in "${fileRecord.name}". Use a longer, unique search string.`,
+                message: `Patch failed: search string is ambiguous — found at multiple locations in "${fileRecord.name}". Use a longer unique search string or replaceAll.`,
               }
             }
-            content =
-              content.slice(0, firstIdx) +
-              edit.replace +
-              content.slice(firstIdx + edit.search.length)
-          }
-
-          const isPptxPatch = fileRecord.name?.toLowerCase().endsWith('.pptx')
-          if (isPptxPatch) {
-            try {
-              await generatePptxFromCode(content, workspaceId)
-            } catch (err) {
-              const msg = err instanceof Error ? err.message : String(err)
-              return {
-                success: false,
-                message: `Patched PPTX code failed to compile: ${msg}. Fix the edits and retry.`,
-              }
+          } else if (normalized.edit.strategy === 'anchored') {
+            if (!normalized.edit.mode) {
+              return { success: false, message: 'anchored strategy requires mode' }
+            }
+          } else {
+            return {
+              success: false,
+              message: `Unknown patch strategy: "${(normalized.edit as { strategy?: string }).strategy}"`,
             }
           }
 
-          const patchedBuffer = Buffer.from(content, 'utf-8')
-          assertServerToolNotAborted(context)
-          await updateWorkspaceFileContent(
+          await storeFileIntent(workspaceId, target.fileId, {
+            operation: 'patch',
+            fileId: target.fileId,
             workspaceId,
-            fileId,
-            context.userId,
-            patchedBuffer,
-            isPptxPatch ? PPTX_SOURCE_MIME : undefined
-          )
-
-          reqLogger.info('Workspace file patched via copilot', {
-            fileId,
-            name: fileRecord.name,
-            editCount: edits.length,
             userId: context.userId,
+            chatId: context.chatId,
+            messageId: context.messageId,
+            fileRecord,
+            existingContent,
+            edit: {
+              strategy: normalized.edit.strategy,
+              ...(normalized.edit.strategy === 'search_replace'
+                ? {
+                    search: normalized.edit.search,
+                    replaceAll: normalized.edit.replaceAll,
+                  }
+                : {
+                    mode: normalized.edit.mode,
+                    occurrence: normalized.edit.occurrence,
+                    before_anchor: normalized.edit.before_anchor,
+                    after_anchor: normalized.edit.after_anchor,
+                    anchor: normalized.edit.anchor,
+                    start_anchor: normalized.edit.start_anchor,
+                    end_anchor: normalized.edit.end_anchor,
+                  }),
+            },
+            contentType: normalized.contentType,
+            title: normalized.title,
+            createdAt: Date.now(),
           })
 
           return {
             success: true,
-            message: `File "${fileRecord.name}" patched successfully (${edits.length} edit${edits.length > 1 ? 's' : ''} applied)`,
-            data: {
-              id: fileId,
-              name: fileRecord.name,
-              size: patchedBuffer.length,
-            },
+            message: withMessageId(
+              `Intent set: patch "${fileRecord.name}" (${normalized.edit.strategy}). Wait for this success result, then call edit_content in the next step with the replacement/insert content. Do not call edit_content in parallel.`
+            ),
+            data: { id: target.fileId, name: fileRecord.name, operation: 'patch' },
           }
         }
 
         default:
           return {
             success: false,
-            message: `Unknown operation: ${operation}. Supported: write, update, patch, rename, delete.`,
+            message: `Unknown operation: ${operation}. Supported: create, append, update, patch, rename, delete.`,
           }
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred'
-      reqLogger.error('Error in workspace_file tool', {
+      logger.error('Error in workspace_file tool', {
         operation,
         error: errorMessage,
         userId: context.userId,
diff --git a/apps/sim/lib/copilot/tools/server/generated-schema.ts b/apps/sim/lib/copilot/tools/server/generated-schema.ts
new file mode 100644
index 00000000000..579e969efa7
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/generated-schema.ts
@@ -0,0 +1,49 @@
+import Ajv, { type ErrorObject, type ValidateFunction } from 'ajv'
+import { TOOL_RUNTIME_SCHEMAS } from '@/lib/copilot/generated/tool-schemas-v1'
+
+const ajv = new Ajv({
+  allErrors: true,
+  strict: false,
+})
+
+const validatorCache = new Map<string, ValidateFunction>()
+
+function formatErrors(errors: ErrorObject[] | null | undefined): string {
+  if (!errors || errors.length === 0) return 'unknown validation error'
+  return errors
+    .slice(0, 5)
+    .map((error) => `${error.instancePath || '/'} ${error.message || 'is invalid'}`.trim())
+    .join('; ')
+}
+
+function getValidator(
+  toolName: string,
+  schemaKind: 'parameters' | 'resultSchema'
+): ValidateFunction | null {
+  const cacheKey = `${toolName}:${schemaKind}`
+  const cached = validatorCache.get(cacheKey)
+  if (cached) return cached
+
+  const schema = TOOL_RUNTIME_SCHEMAS[toolName]?.[schemaKind]
+  if (!schema) return null
+
+  const validator = ajv.compile(schema as object)
+  validatorCache.set(cacheKey, validator)
+  return validator
+}
+
+export function validateGeneratedToolPayload<T>(
+  toolName: string,
+  schemaKind: 'parameters' | 'resultSchema',
+  payload: T
+): T {
+  const validator = getValidator(toolName, schemaKind)
+  if (!validator) return payload
+
+  if (!validator(payload)) {
+    const label = schemaKind === 'parameters' ? 'input' : 'output'
+    throw new Error(`${toolName} ${label} validation failed: ${formatErrors(validator.errors)}`)
+  }
+
+  return payload
+}
diff --git a/apps/sim/lib/copilot/tools/server/image/generate-image.ts b/apps/sim/lib/copilot/tools/server/image/generate-image.ts
index 283ac69f92c..7a8ac769ab2 100644
--- a/apps/sim/lib/copilot/tools/server/image/generate-image.ts
+++ b/apps/sim/lib/copilot/tools/server/image/generate-image.ts
@@ -1,5 +1,6 @@
 import { GoogleGenAI, type Part } from '@google/genai'
 import { createLogger } from '@sim/logger'
+import { GenerateImage } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -54,13 +55,14 @@ interface GenerateImageResult {
 }
 
 export const generateImageServerTool: BaseServerTool<GenerateImageArgs, GenerateImageResult> = {
-  name: 'generate_image',
+  name: GenerateImage.id,
 
   async execute(
     params: GenerateImageArgs,
     context?: ServerToolContext
   ): Promise<GenerateImageResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       throw new Error('Authentication required')
@@ -83,29 +85,31 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
       const sizeHint = ASPECT_RATIO_TO_SIZE[aspectRatio]
 
       const parts: Part[] = []
+      const referenceRecords: Array<{ id: string; name: string }> = []
 
       if (params.referenceFileIds?.length) {
         for (const fileId of params.referenceFileIds) {
           try {
             const fileRecord = await getWorkspaceFile(workspaceId, fileId)
             if (fileRecord) {
+              referenceRecords.push({ id: fileRecord.id, name: fileRecord.name })
               const buffer = await downloadWorkspaceFile(fileRecord)
               const base64 = buffer.toString('base64')
               const mime = fileRecord.type || 'image/png'
               parts.push({
                 inlineData: { mimeType: mime, data: base64 },
               })
-              reqLogger.info('Loaded reference image', {
+              logger.info('Loaded reference image', {
                 fileId,
                 name: fileRecord.name,
                 size: buffer.length,
                 mimeType: mime,
               })
             } else {
-              reqLogger.warn('Reference file not found, skipping', { fileId })
+              logger.warn('Reference file not found, skipping', { fileId })
             }
           } catch (err) {
-            reqLogger.warn('Failed to load reference image, skipping', {
+            logger.warn('Failed to load reference image, skipping', {
               fileId,
               error: err instanceof Error ? err.message : String(err),
             })
@@ -119,7 +123,7 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
 
       parts.push({ text: prompt + sizeInstruction })
 
-      reqLogger.info('Generating image with Nano Banana 2', {
+      logger.info('Generating image with Nano Banana 2', {
         model: NANO_BANANA_MODEL,
         aspectRatio,
         promptLength: prompt.length,
@@ -167,24 +171,36 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
         return { success: false, message: fileNameValidationError }
       }
       const imageBuffer = Buffer.from(imageBase64, 'base64')
+      const inferredOverwriteFileId =
+        !params.overwriteFileId && params.fileName
+          ? referenceRecords.find((record) => record.name === fileName)?.id
+          : undefined
+      const overwriteFileId = params.overwriteFileId ?? inferredOverwriteFileId
+
+      if (inferredOverwriteFileId) {
+        logger.info('Inferring overwrite target from referenced file name', {
+          fileName,
+          overwriteFileId: inferredOverwriteFileId,
+        })
+      }
 
-      if (params.overwriteFileId) {
-        const existing = await getWorkspaceFile(workspaceId, params.overwriteFileId)
+      if (overwriteFileId) {
+        const existing = await getWorkspaceFile(workspaceId, overwriteFileId)
         if (!existing) {
           return {
             success: false,
-            message: `File not found for overwrite: ${params.overwriteFileId}`,
+            message: `File not found for overwrite: ${overwriteFileId}`,
           }
         }
         assertServerToolNotAborted(context)
         const updated = await updateWorkspaceFileContent(
           workspaceId,
-          params.overwriteFileId,
+          overwriteFileId,
           context.userId,
           imageBuffer,
           mimeType
         )
-        reqLogger.info('Generated image overwritten', {
+        logger.info('Generated image overwritten', {
           fileId: updated.id,
           fileName: updated.name,
           size: imageBuffer.length,
@@ -210,7 +226,7 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
         mimeType
       )
 
-      reqLogger.info('Generated image saved', {
+      logger.info('Generated image saved', {
         fileId: uploaded.id,
         fileName: uploaded.name,
         size: imageBuffer.length,
@@ -227,7 +243,7 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : 'Unknown error'
-      reqLogger.error('Image generation failed', { error: msg })
+      logger.error('Image generation failed', { error: msg })
       return { success: false, message: `Failed to generate image: ${msg}` }
     }
   },
diff --git a/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts b/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts
index 76f01c70f59..90ed8fbbe51 100644
--- a/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts
+++ b/apps/sim/lib/copilot/tools/server/jobs/get-job-logs.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { jobExecutionLogs } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq } from 'drizzle-orm'
+import { GetJobLogs } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
 import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -83,9 +84,10 @@ function extractOutputAndError(executionData: any): {
 }
 
 export const getJobLogsServerTool: BaseServerTool<GetJobLogsArgs, JobLogEntry[]> = {
-  name: 'get_job_logs',
+  name: GetJobLogs.id,
   async execute(rawArgs: GetJobLogsArgs, context?: ServerToolContext): Promise<JobLogEntry[]> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     const {
       jobId,
@@ -112,7 +114,7 @@ export const getJobLogsServerTool: BaseServerTool<GetJobLogsArgs, JobLogEntry[]>
 
     const clampedLimit = Math.min(Math.max(1, limit), 5)
 
-    reqLogger.info('Fetching job logs', {
+    logger.info('Fetching job logs', {
       jobId,
       executionId,
       limit: clampedLimit,
@@ -171,7 +173,7 @@ export const getJobLogsServerTool: BaseServerTool<GetJobLogsArgs, JobLogEntry[]>
       return entry
     })
 
-    reqLogger.info('Job logs prepared', {
+    logger.info('Job logs prepared', {
       jobId,
       count: entries.length,
       resultSizeKB: Math.round(JSON.stringify(entries).length / 1024),
diff --git a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
index 5cc6538025d..67c7f655f8c 100644
--- a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
+++ b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
@@ -3,12 +3,12 @@ import { knowledgeConnector } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, isNull } from 'drizzle-orm'
 import { generateInternalToken } from '@/lib/auth/internal'
+import { KnowledgeBase } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
-import type { KnowledgeBaseArgs, KnowledgeBaseResult } from '@/lib/copilot/tools/shared/schemas'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
 import { generateId } from '@/lib/core/utils/uuid'
 import {
@@ -39,21 +39,31 @@ import { getQueryStrategy, handleVectorOnlySearch } from '@/app/api/knowledge/se
 
 const logger = createLogger('KnowledgeBaseServerTool')
 
+type KnowledgeBaseArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type KnowledgeBaseResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
 /**
  * Knowledge base tool for copilot to create, list, and get knowledge bases
  */
 export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, KnowledgeBaseResult> = {
-  name: 'knowledge_base',
+  name: KnowledgeBase.id,
   async execute(
     params: KnowledgeBaseArgs,
     context?: ServerToolContext
   ): Promise<KnowledgeBaseResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
-      reqLogger.error(
-        'Unauthorized attempt to access knowledge base - no authenticated user context'
-      )
+      logger.error('Unauthorized attempt to access knowledge base - no authenticated user context')
       throw new Error('Authentication required')
     }
 
@@ -102,7 +112,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             requestId
           )
 
-          reqLogger.info('Knowledge base created via copilot', {
+          logger.info('Knowledge base created via copilot', {
             knowledgeBaseId: newKnowledgeBase.id,
             name: newKnowledgeBase.name,
             userId: context.userId,
@@ -138,7 +148,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             }
           }
 
-          reqLogger.info('Knowledge base metadata retrieved via copilot', {
+          logger.info('Knowledge base metadata retrieved via copilot', {
             knowledgeBaseId: knowledgeBase.id,
             userId: context.userId,
           })
@@ -202,7 +212,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             distanceThreshold: strategy.distanceThreshold,
           })
 
-          reqLogger.info('Knowledge base queried via copilot', {
+          logger.info('Knowledge base queried via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             query: args.query.substring(0, 100),
             resultCount: results.length,
@@ -236,12 +246,13 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             }
           }
 
-          const fileReference = args.fileId || args.filePath
-          if (!fileReference) {
+          const fileIds: string[] =
+            args.fileIds ?? (args.fileId ? [args.fileId] : args.filePath ? [args.filePath] : [])
+          if (fileIds.length === 0) {
             return {
               success: false,
               message:
-                'fileId is required for add_file. Read files/{name}/meta.json or files/by-id/*/meta.json to get the canonical file ID.',
+                'fileIds is required for add_file. Read files/{name}/meta.json or files/by-id/*/meta.json to get the canonical file IDs.',
             }
           }
 
@@ -254,68 +265,74 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           }
 
           const kbWorkspaceId: string = targetKb.workspaceId
-          const fileRecord = await resolveWorkspaceFileReference(kbWorkspaceId, fileReference)
-
-          if (!fileRecord) {
-            return {
-              success: false,
-              message: `Workspace file not found: "${fileReference}"`,
+          const added: Array<{ documentId: string; filename: string }> = []
+          const failedFiles: string[] = []
+
+          for (const fileRef of fileIds) {
+            const fileRecord = await resolveWorkspaceFileReference(kbWorkspaceId, fileRef)
+            if (!fileRecord) {
+              failedFiles.push(fileRef)
+              continue
             }
-          }
 
-          const presignedUrl = await StorageService.generatePresignedDownloadUrl(
-            fileRecord.key,
-            'workspace',
-            5 * 60
-          )
+            const presignedUrl = await StorageService.generatePresignedDownloadUrl(
+              fileRecord.key,
+              'workspace',
+              5 * 60
+            )
+
+            const requestId = generateId().slice(0, 8)
+            assertNotAborted()
+            const doc = await createSingleDocument(
+              {
+                filename: fileRecord.name,
+                fileUrl: presignedUrl,
+                fileSize: fileRecord.size,
+                mimeType: fileRecord.type,
+              },
+              args.knowledgeBaseId,
+              requestId
+            )
+
+            processDocumentAsync(
+              args.knowledgeBaseId,
+              doc.id,
+              {
+                filename: fileRecord.name,
+                fileUrl: presignedUrl,
+                fileSize: fileRecord.size,
+                mimeType: fileRecord.type,
+              },
+              {}
+            ).catch((err) => {
+              logger.error('Background document processing failed', {
+                documentId: doc.id,
+                error: err instanceof Error ? err.message : String(err),
+              })
+            })
 
-          const requestId = generateId().slice(0, 8)
-          assertNotAborted()
-          const doc = await createSingleDocument(
-            {
-              filename: fileRecord.name,
-              fileUrl: presignedUrl,
-              fileSize: fileRecord.size,
-              mimeType: fileRecord.type,
-            },
-            args.knowledgeBaseId,
-            requestId
-          )
+            added.push({ documentId: doc.id, filename: fileRecord.name })
 
-          processDocumentAsync(
-            args.knowledgeBaseId,
-            doc.id,
-            {
-              filename: fileRecord.name,
-              fileUrl: presignedUrl,
-              fileSize: fileRecord.size,
-              mimeType: fileRecord.type,
-            },
-            {}
-          ).catch((err) => {
-            reqLogger.error('Background document processing failed', {
+            logger.info('Workspace file added to knowledge base via copilot', {
+              knowledgeBaseId: args.knowledgeBaseId,
               documentId: doc.id,
-              error: err instanceof Error ? err.message : String(err),
+              fileName: fileRecord.name,
+              userId: context.userId,
             })
-          })
-
-          reqLogger.info('Workspace file added to knowledge base via copilot', {
-            knowledgeBaseId: args.knowledgeBaseId,
-            documentId: doc.id,
-            fileName: fileRecord.name,
-            userId: context.userId,
-          })
+          }
 
+          const addedNames = added.map((a) => a.filename).join(', ')
           return {
-            success: true,
-            message: `File "${fileRecord.name}" added to knowledge base "${targetKb.name}". Processing started (chunking + embedding).`,
+            success: added.length > 0,
+            message:
+              added.length > 0
+                ? `Added ${added.length} file(s) to "${targetKb.name}": ${addedNames}. Processing started.`
+                : `No files could be added.`,
             data: {
-              documentId: doc.id,
               knowledgeBaseId: args.knowledgeBaseId,
               knowledgeBaseName: targetKb.name,
-              filename: fileRecord.name,
-              fileSize: fileRecord.size,
-              mimeType: fileRecord.type,
+              added,
+              failed: failedFiles,
             },
           }
         }
@@ -349,7 +366,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           assertNotAborted()
           const updatedKb = await updateKnowledgeBase(args.knowledgeBaseId, updates, requestId)
 
-          reqLogger.info('Knowledge base updated via copilot', {
+          logger.info('Knowledge base updated via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             userId: context.userId,
           })
@@ -369,38 +386,44 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
         }
 
         case 'delete': {
-          if (!args.knowledgeBaseId) {
+          const kbIds: string[] =
+            args.knowledgeBaseIds ?? (args.knowledgeBaseId ? [args.knowledgeBaseId] : [])
+          if (kbIds.length === 0) {
             return {
               success: false,
-              message: 'Knowledge base ID is required for delete operation',
+              message: 'knowledgeBaseId or knowledgeBaseIds is required for delete operation',
             }
           }
 
-          const kbToDelete = await getKnowledgeBaseById(args.knowledgeBaseId)
-          if (!kbToDelete) {
-            return {
-              success: false,
-              message: `Knowledge base with ID "${args.knowledgeBaseId}" not found`,
+          const deleted: Array<{ id: string; name: string }> = []
+          const notFound: string[] = []
+
+          for (const kbId of kbIds) {
+            const kbToDelete = await getKnowledgeBaseById(kbId)
+            if (!kbToDelete) {
+              notFound.push(kbId)
+              continue
             }
-          }
 
-          const requestId = generateId().slice(0, 8)
-          assertNotAborted()
-          await deleteKnowledgeBase(args.knowledgeBaseId, requestId)
+            const requestId = generateId().slice(0, 8)
+            assertNotAborted()
+            await deleteKnowledgeBase(kbId, requestId)
+            deleted.push({ id: kbId, name: kbToDelete.name })
 
-          reqLogger.info('Knowledge base deleted via copilot', {
-            knowledgeBaseId: args.knowledgeBaseId,
-            name: kbToDelete.name,
-            userId: context.userId,
-          })
+            logger.info('Knowledge base deleted via copilot', {
+              knowledgeBaseId: kbId,
+              name: kbToDelete.name,
+              userId: context.userId,
+            })
+          }
 
           return {
-            success: true,
-            message: `Knowledge base "${kbToDelete.name}" deleted successfully`,
-            data: {
-              id: args.knowledgeBaseId,
-              name: kbToDelete.name,
-            },
+            success: deleted.length > 0,
+            message:
+              deleted.length > 0
+                ? `Deleted: ${deleted.map((d) => d.name).join(', ')}`
+                : 'No knowledge bases found',
+            data: { deleted, notFound },
           }
         }
 
@@ -408,16 +431,32 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           if (!args.knowledgeBaseId) {
             return { success: false, message: 'knowledgeBaseId is required for delete_document' }
           }
-          if (!args.documentId) {
-            return { success: false, message: 'documentId is required for delete_document' }
+          const docIds: string[] = args.documentIds ?? (args.documentId ? [args.documentId] : [])
+          if (docIds.length === 0) {
+            return {
+              success: false,
+              message: 'documentId or documentIds is required for delete_document',
+            }
           }
-          const requestId = generateId().slice(0, 8)
-          assertNotAborted()
-          const result = await deleteDocument(args.documentId, requestId)
+
+          const deleted: string[] = []
+          const failed: string[] = []
+
+          for (const docId of docIds) {
+            const requestId = generateId().slice(0, 8)
+            assertNotAborted()
+            const result = await deleteDocument(docId, requestId)
+            if (result.success) {
+              deleted.push(docId)
+            } else {
+              failed.push(docId)
+            }
+          }
+
           return {
-            success: result.success,
-            message: result.message,
-            data: { documentId: args.documentId, knowledgeBaseId: args.knowledgeBaseId },
+            success: deleted.length > 0,
+            message: `Deleted ${deleted.length} document(s)${failed.length > 0 ? `, ${failed.length} failed` : ''}`,
+            data: { knowledgeBaseId: args.knowledgeBaseId, deleted, failed },
           }
         }
 
@@ -465,7 +504,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
 
           const tagDefinitions = await getDocumentTagDefinitions(args.knowledgeBaseId)
 
-          reqLogger.info('Tag definitions listed via copilot', {
+          logger.info('Tag definitions listed via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             count: tagDefinitions.length,
             userId: context.userId,
@@ -519,7 +558,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             requestId
           )
 
-          reqLogger.info('Tag definition created via copilot', {
+          logger.info('Tag definition created via copilot', {
             knowledgeBaseId: args.knowledgeBaseId,
             tagId: newTag.id,
             displayName: newTag.displayName,
@@ -570,7 +609,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           assertNotAborted()
           const updatedTag = await updateTagDefinition(args.tagDefinitionId, updateData, requestId)
 
-          reqLogger.info('Tag definition updated via copilot', {
+          logger.info('Tag definition updated via copilot', {
             tagId: args.tagDefinitionId,
             knowledgeBaseId: existingTag.knowledgeBaseId,
             userId: context.userId,
@@ -611,7 +650,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             requestId
           )
 
-          reqLogger.info('Tag definition deleted via copilot', {
+          logger.info('Tag definition deleted via copilot', {
             tagId: args.tagDefinitionId,
             tagSlot: deleted.tagSlot,
             displayName: deleted.displayName,
@@ -693,7 +732,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           }
 
           const connector = createRes.data
-          reqLogger.info('Connector created via copilot', {
+          logger.info('Connector created via copilot', {
             connectorId: connector.id,
             connectorType: args.connectorType,
             knowledgeBaseId: args.knowledgeBaseId,
@@ -748,7 +787,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             return { success: false, message: updateRes.error ?? 'Failed to update connector' }
           }
 
-          reqLogger.info('Connector updated via copilot', {
+          logger.info('Connector updated via copilot', {
             connectorId: args.connectorId,
             userId: context.userId,
           })
@@ -781,7 +820,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             return { success: false, message: deleteRes.error ?? 'Failed to delete connector' }
           }
 
-          reqLogger.info('Connector deleted via copilot', {
+          logger.info('Connector deleted via copilot', {
             connectorId: args.connectorId,
             userId: context.userId,
           })
@@ -814,7 +853,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             return { success: false, message: syncRes.error ?? 'Failed to sync connector' }
           }
 
-          reqLogger.info('Connector sync triggered via copilot', {
+          logger.info('Connector sync triggered via copilot', {
             connectorId: args.connectorId,
             userId: context.userId,
           })
@@ -834,7 +873,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred'
-      reqLogger.error('Error in knowledge_base tool', {
+      logger.error('Error in knowledge_base tool', {
         operation,
         error: errorMessage,
         userId: context.userId,
diff --git a/apps/sim/lib/copilot/tools/server/other/make-api-request.ts b/apps/sim/lib/copilot/tools/server/other/make-api-request.ts
deleted file mode 100644
index 3f95460511a..00000000000
--- a/apps/sim/lib/copilot/tools/server/other/make-api-request.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
-import { executeTool } from '@/tools'
-import type { TableRow } from '@/tools/types'
-
-const RESULT_CHAR_CAP = Number(process.env.COPILOT_TOOL_RESULT_CHAR_CAP || 20000)
-
-interface MakeApiRequestParams {
-  url: string
-  method: 'GET' | 'POST' | 'PUT'
-  queryParams?: Record<string, string | number | boolean>
-  headers?: Record<string, string>
-  body?: unknown
-}
-
-interface ApiResponse {
-  data: string
-  status: number
-  headers: Record<string, string>
-  truncated?: boolean
-  totalChars?: number
-  previewChars?: number
-  note?: string
-}
-
-export const makeApiRequestServerTool: BaseServerTool<MakeApiRequestParams, ApiResponse> = {
-  name: 'make_api_request',
-  async execute(params: MakeApiRequestParams): Promise<ApiResponse> {
-    const logger = createLogger('MakeApiRequestServerTool')
-    const { url, method, queryParams, headers, body } = params
-    if (!url || !method) throw new Error('url and method are required')
-
-    const toTableRows = (obj?: Record<string, unknown>): TableRow[] | null => {
-      if (!obj || typeof obj !== 'object') return null
-      return Object.entries(obj).map(([key, value]) => ({
-        id: key,
-        cells: { Key: key, Value: value },
-      }))
-    }
-    const headersTable = toTableRows(headers)
-    const queryParamsTable = toTableRows(queryParams as Record<string, unknown> | undefined)
-
-    const result = await executeTool(
-      'http_request',
-      { url, method, params: queryParamsTable, headers: headersTable, body },
-      true
-    )
-    if (!result.success) throw new Error(result.error ?? 'API request failed')
-
-    const output = result.output as Record<string, unknown> | undefined
-    const nestedOutput = output?.output as Record<string, unknown> | undefined
-    const data = nestedOutput?.data ?? output?.data
-    const status = (nestedOutput?.status ?? output?.status ?? 200) as number
-    const respHeaders = (nestedOutput?.headers ?? output?.headers ?? {}) as Record<string, string>
-
-    const toStringSafe = (val: unknown): string => {
-      if (typeof val === 'string') return val
-      try {
-        return JSON.stringify(val)
-      } catch {
-        return String(val)
-      }
-    }
-
-    const stripHtml = (html: string): string => {
-      try {
-        let text = html
-        let previous: string
-        do {
-          previous = text
-          text = text.replace(/<script[\s\S]*?<\/script\s*>/gi, '')
-          text = text.replace(/<style[\s\S]*?<\/style\s*>/gi, '')
-          text = text.replace(/<[^>]*>/g, ' ')
-          text = text.replace(/[<>]/g, ' ')
-        } while (text !== previous)
-        return text.replace(/\s+/g, ' ').trim()
-      } catch {
-        return html
-      }
-    }
-
-    let normalized = toStringSafe(data)
-    const looksLikeHtml =
-      /<html[\s\S]*<\/html>/i.test(normalized) || /<body[\s\S]*<\/body>/i.test(normalized)
-    if (looksLikeHtml) normalized = stripHtml(normalized)
-
-    const totalChars = normalized.length
-    if (totalChars > RESULT_CHAR_CAP) {
-      const preview = normalized.slice(0, RESULT_CHAR_CAP)
-      logger.warn('API response truncated', { url, method, totalChars, cap: RESULT_CHAR_CAP })
-      return {
-        data: preview,
-        status,
-        headers: respHeaders,
-        truncated: true,
-        totalChars,
-        previewChars: preview.length,
-        note: `Response truncated to ${RESULT_CHAR_CAP} characters`,
-      }
-    }
-
-    logger.debug('API request executed', { url, method, status, totalChars })
-    return { data: normalized, status, headers: respHeaders }
-  },
-}
diff --git a/apps/sim/lib/copilot/tools/server/other/search-online.ts b/apps/sim/lib/copilot/tools/server/other/search-online.ts
index 75f59b507f8..f9a50956f77 100644
--- a/apps/sim/lib/copilot/tools/server/other/search-online.ts
+++ b/apps/sim/lib/copilot/tools/server/other/search-online.ts
@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import { SearchOnline } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { env } from '@/lib/core/config/env'
 import { executeTool } from '@/tools'
@@ -28,7 +29,7 @@ interface SearchResponse {
 }
 
 export const searchOnlineServerTool: BaseServerTool<OnlineSearchParams, SearchResponse> = {
-  name: 'search_online',
+  name: SearchOnline.id,
   async execute(params: OnlineSearchParams): Promise<SearchResponse> {
     const logger = createLogger('SearchOnlineServerTool')
     const { query, num = 10, type = 'search', gl, hl } = params
diff --git a/apps/sim/lib/copilot/tools/server/router.ts b/apps/sim/lib/copilot/tools/server/router.ts
index 18dfdc7deb0..9dd09628639 100644
--- a/apps/sim/lib/copilot/tools/server/router.ts
+++ b/apps/sim/lib/copilot/tools/server/router.ts
@@ -1,4 +1,20 @@
 import { createLogger } from '@sim/logger'
+import { z } from 'zod'
+import {
+  CreateFile,
+  DeleteFile,
+  DownloadToWorkspaceFile,
+  GenerateImage,
+  GenerateVisualization,
+  KnowledgeBase,
+  ManageCredential,
+  ManageCustomTool,
+  ManageMcpTool,
+  ManageSkill,
+  RenameFile,
+  UserTable,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -7,12 +23,16 @@ import {
 import { getBlocksMetadataServerTool } from '@/lib/copilot/tools/server/blocks/get-blocks-metadata-tool'
 import { getTriggerBlocksServerTool } from '@/lib/copilot/tools/server/blocks/get-trigger-blocks'
 import { searchDocumentationServerTool } from '@/lib/copilot/tools/server/docs/search-documentation'
+import { createFileServerTool } from '@/lib/copilot/tools/server/files/create-file'
+import { deleteFileServerTool } from '@/lib/copilot/tools/server/files/delete-file'
 import { downloadToWorkspaceFileServerTool } from '@/lib/copilot/tools/server/files/download-to-workspace-file'
+import { editContentServerTool } from '@/lib/copilot/tools/server/files/edit-content'
+import { renameFileServerTool } from '@/lib/copilot/tools/server/files/rename-file'
 import { workspaceFileServerTool } from '@/lib/copilot/tools/server/files/workspace-file'
+import { validateGeneratedToolPayload } from '@/lib/copilot/tools/server/generated-schema'
 import { generateImageServerTool } from '@/lib/copilot/tools/server/image/generate-image'
 import { getJobLogsServerTool } from '@/lib/copilot/tools/server/jobs/get-job-logs'
 import { knowledgeBaseServerTool } from '@/lib/copilot/tools/server/knowledge/knowledge-base'
-import { makeApiRequestServerTool } from '@/lib/copilot/tools/server/other/make-api-request'
 import { searchOnlineServerTool } from '@/lib/copilot/tools/server/other/search-online'
 import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
 import { getCredentialsServerTool } from '@/lib/copilot/tools/server/user/get-credentials'
@@ -21,15 +41,19 @@ import { generateVisualizationServerTool } from '@/lib/copilot/tools/server/visu
 import { editWorkflowServerTool } from '@/lib/copilot/tools/server/workflow/edit-workflow'
 import { getExecutionSummaryServerTool } from '@/lib/copilot/tools/server/workflow/get-execution-summary'
 import { getWorkflowLogsServerTool } from '@/lib/copilot/tools/server/workflow/get-workflow-logs'
-import { ExecuteResponseSuccessSchema } from '@/lib/copilot/tools/shared/schemas'
 
 export { ExecuteResponseSuccessSchema }
 export type ExecuteResponseSuccess = (typeof ExecuteResponseSuccessSchema)['_type']
 
+const ExecuteResponseSuccessSchema = z.object({
+  success: z.literal(true),
+  result: z.unknown(),
+})
+
 const logger = createLogger('ServerToolRouter')
 
 const WRITE_ACTIONS: Record<string, string[]> = {
-  knowledge_base: [
+  [KnowledgeBase.id]: [
     'create',
     'add_file',
     'update',
@@ -44,7 +68,7 @@ const WRITE_ACTIONS: Record<string, string[]> = {
     'delete_connector',
     'sync_connector',
   ],
-  user_table: [
+  [UserTable.id]: [
     'create',
     'create_from_file',
     'import_file',
@@ -60,14 +84,18 @@ const WRITE_ACTIONS: Record<string, string[]> = {
     'delete_column',
     'update_column',
   ],
-  manage_custom_tool: ['add', 'edit', 'delete'],
-  manage_mcp_tool: ['add', 'edit', 'delete'],
-  manage_skill: ['add', 'edit', 'delete'],
-  manage_credential: ['rename', 'delete'],
-  workspace_file: ['write', 'update', 'delete', 'rename', 'patch'],
-  download_to_workspace_file: ['*'],
-  generate_visualization: ['generate'],
-  generate_image: ['generate'],
+  [ManageCustomTool.id]: ['add', 'edit', 'delete'],
+  [ManageMcpTool.id]: ['add', 'edit', 'delete'],
+  [ManageSkill.id]: ['add', 'edit', 'delete'],
+  [ManageCredential.id]: ['rename', 'delete'],
+  [WorkspaceFile.id]: ['create', 'append', 'update', 'delete', 'rename', 'patch'],
+  [editContentServerTool.name]: ['*'],
+  [CreateFile.id]: ['*'],
+  [RenameFile.id]: ['*'],
+  [DeleteFile.id]: ['*'],
+  [DownloadToWorkspaceFile.id]: ['*'],
+  [GenerateVisualization.id]: ['generate'],
+  [GenerateImage.id]: ['generate'],
 }
 
 function isWritePermission(userPermission: string): boolean {
@@ -99,19 +127,22 @@ const serverToolRegistry: Record<string, BaseServerTool> = {
   [searchOnlineServerTool.name]: searchOnlineServerTool,
   [setEnvironmentVariablesServerTool.name]: setEnvironmentVariablesServerTool,
   [getCredentialsServerTool.name]: getCredentialsServerTool,
-  [makeApiRequestServerTool.name]: makeApiRequestServerTool,
   [knowledgeBaseServerTool.name]: knowledgeBaseServerTool,
   [userTableServerTool.name]: userTableServerTool,
   [workspaceFileServerTool.name]: workspaceFileServerTool,
+  [editContentServerTool.name]: editContentServerTool,
+  [createFileServerTool.name]: createFileServerTool,
+  [renameFileServerTool.name]: renameFileServerTool,
+  [deleteFileServerTool.name]: deleteFileServerTool,
   [downloadToWorkspaceFileServerTool.name]: downloadToWorkspaceFileServerTool,
   [generateVisualizationServerTool.name]: generateVisualizationServerTool,
   [generateImageServerTool.name]: generateImageServerTool,
 }
 
-/**
- * Route a tool execution request to the appropriate server tool.
- * Validates input/output using the tool's declared Zod schemas if present.
- */
+export function getRegisteredServerToolNames(): string[] {
+  return Object.keys(serverToolRegistry)
+}
+
 export async function routeExecution(
   toolName: string,
   payload: unknown,
@@ -122,9 +153,10 @@ export async function routeExecution(
     throw new Error(`Unknown server tool: ${toolName}`)
   }
 
-  logger.withMetadata({ messageId: context?.messageId }).debug('Routing to tool', {
-    toolName,
-  })
+  logger.debug(
+    context?.messageId ? `Routing to tool [messageId:${context.messageId}]` : 'Routing to tool',
+    { toolName }
+  )
 
   // Action-level permission enforcement for mixed read/write tools
   if (context?.userPermission && WRITE_ACTIONS[toolName]) {
@@ -138,16 +170,39 @@ export async function routeExecution(
     }
   }
 
-  assertServerToolNotAborted(context)
+  assertServerToolNotAborted(
+    context,
+    `User stop signal aborted ${toolName} before payload normalization`
+  )
+
+  // Go injects chatId/workspaceId and may wrap the model's args inside a
+  // nested "args" object. Unwrap that before validation so the generated
+  // JSON Schema sees the flat tool contract shape.
+  let normalizedPayload = payload ?? {}
+  if (
+    normalizedPayload &&
+    typeof normalizedPayload === 'object' &&
+    !Array.isArray(normalizedPayload)
+  ) {
+    const raw = normalizedPayload as Record<string, unknown>
+    if (raw.args && typeof raw.args === 'object' && !raw.operation) {
+      const nested = raw.args as Record<string, unknown>
+      normalizedPayload = { ...nested, ...raw, args: undefined }
+    }
+  }
 
-  // Validate input if tool declares a schema
-  const args = tool.inputSchema ? tool.inputSchema.parse(payload ?? {}) : (payload ?? {})
+  const args = tool.inputSchema
+    ? tool.inputSchema.parse(normalizedPayload)
+    : validateGeneratedToolPayload(toolName, 'parameters', normalizedPayload)
 
-  assertServerToolNotAborted(context)
+  assertServerToolNotAborted(context, `User stop signal aborted ${toolName} after validation`)
 
   // Execute
   const result = await tool.execute(args, context)
 
-  // Validate output if tool declares a schema
-  return tool.outputSchema ? tool.outputSchema.parse(result) : result
+  // Validate output if tool declares a schema; otherwise fall back to the
+  // generated JSON schema contract emitted from Go.
+  return tool.outputSchema
+    ? tool.outputSchema.parse(result)
+    : validateGeneratedToolPayload(toolName, 'resultSchema', result)
 }
diff --git a/apps/sim/lib/copilot/tools/server/table/user-table.ts b/apps/sim/lib/copilot/tools/server/table/user-table.ts
index e324c4c2b7b..626de7a938d 100644
--- a/apps/sim/lib/copilot/tools/server/table/user-table.ts
+++ b/apps/sim/lib/copilot/tools/server/table/user-table.ts
@@ -1,10 +1,10 @@
 import { createLogger } from '@sim/logger'
+import { UserTable } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
-import type { UserTableArgs, UserTableResult } from '@/lib/copilot/tools/shared/schemas'
 import { generateId } from '@/lib/core/utils/uuid'
 import { COLUMN_TYPES } from '@/lib/table/constants'
 import {
@@ -37,6 +37,17 @@ import {
 
 const logger = createLogger('UserTableServerTool')
 
+type UserTableArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type UserTableResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
 const MAX_BATCH_SIZE = 1000
 const SCHEMA_SAMPLE_SIZE = 100
 
@@ -240,9 +251,10 @@ async function batchInsertAll(
 }
 
 export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult> = {
-  name: 'user_table',
+  name: UserTable.id,
   async execute(params: UserTableArgs, context?: ServerToolContext): Promise<UserTableResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       logger.error('Unauthorized attempt to access user table - no authenticated user context')
@@ -323,28 +335,33 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
         }
 
         case 'delete': {
-          if (!args.tableId) {
-            return { success: false, message: 'Table ID is required' }
+          const tableIds: string[] = args.tableIds ?? (args.tableId ? [args.tableId] : [])
+          if (tableIds.length === 0) {
+            return { success: false, message: 'tableId or tableIds is required' }
           }
           if (!workspaceId) {
             return { success: false, message: 'Workspace ID is required' }
           }
 
-          const table = await getTableById(args.tableId)
-          if (!table) {
-            return { success: false, message: `Table not found: ${args.tableId}` }
-          }
-          if (table.workspaceId !== workspaceId) {
-            return { success: false, message: 'Table not found' }
-          }
+          const deleted: string[] = []
+          const failed: string[] = []
 
-          const requestId = generateId().slice(0, 8)
-          assertNotAborted()
-          await deleteTable(args.tableId, requestId)
+          for (const tableId of tableIds) {
+            const table = await getTableById(tableId)
+            if (!table || table.workspaceId !== workspaceId) {
+              failed.push(tableId)
+              continue
+            }
+
+            const requestId = generateId().slice(0, 8)
+            assertNotAborted()
+            await deleteTable(tableId, requestId)
+            deleted.push(tableId)
+          }
 
           return {
-            success: true,
-            message: `Deleted table ${args.tableId}`,
+            success: deleted.length > 0,
+            message: `Deleted ${deleted.length} table(s)${failed.length > 0 ? `, ${failed.length} not found` : ''}`,
           }
         }
 
@@ -726,7 +743,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           const coerced = coerceRows(rows, columns, columnMap)
           const inserted = await batchInsertAll(table.id, coerced, table, workspaceId, context)
 
-          reqLogger.info('Table created from file', {
+          logger.info('Table created from file', {
             tableId: table.id,
             fileName: file.name,
             columns: columns.length,
@@ -802,7 +819,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           const coerced = coerceRows(rows, matchedColumns, columnMap)
           const inserted = await batchInsertAll(table.id, coerced, table, workspaceId, context)
 
-          reqLogger.info('Rows imported from file', {
+          logger.info('Rows imported from file', {
             tableId: table.id,
             fileName: file.name,
             matchedColumns: mappedHeaders.length,
@@ -1000,7 +1017,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             ? error.cause.message
             : String(error.cause)
           : undefined
-      reqLogger.error('Table operation failed', {
+      logger.error('Table operation failed', {
         operation,
         error: errorMessage,
         cause,
diff --git a/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts b/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts
index 30f032e1114..56f1de2043f 100644
--- a/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts
+++ b/apps/sim/lib/copilot/tools/server/user/set-environment-variables.ts
@@ -3,6 +3,7 @@ import { credential } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, inArray } from 'drizzle-orm'
 import { z } from 'zod'
+import { SetEnvironmentVariables } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { upsertPersonalEnvVars, upsertWorkspaceEnvVars } from '@/lib/environment/utils'
 import { getWorkflowById } from '@/lib/workflows/utils'
@@ -35,7 +36,7 @@ function normalizeVariables(
 
 export const setEnvironmentVariablesServerTool: BaseServerTool<SetEnvironmentVariablesParams, any> =
   {
-    name: 'set_environment_variables',
+    name: SetEnvironmentVariables.id,
     async execute(
       params: SetEnvironmentVariablesParams,
       context?: { userId: string }
diff --git a/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts b/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts
index f58c40c4a9f..b639f3f1fe4 100644
--- a/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts
+++ b/apps/sim/lib/copilot/tools/server/visualization/generate-visualization.ts
@@ -1,4 +1,5 @@
 import { createLogger } from '@sim/logger'
+import { GenerateVisualization } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -65,7 +66,8 @@ async function collectSandboxFiles(
   inputTables?: string[],
   messageId?: string
 ): Promise<SandboxFile[]> {
-  const reqLogger = logger.withMetadata({ messageId })
+  const withMessageId = (message: string) =>
+    messageId ? `${message} [messageId:${messageId}]` : message
   const sandboxFiles: SandboxFile[] = []
   let totalSize = 0
 
@@ -74,12 +76,12 @@ async function collectSandboxFiles(
     for (const fileRef of inputFiles) {
       const record = findWorkspaceFileRecord(allFiles, fileRef)
       if (!record) {
-        reqLogger.warn('Sandbox input file not found', { fileRef })
+        logger.warn('Sandbox input file not found', { fileRef })
         continue
       }
       const ext = record.name.split('.').pop()?.toLowerCase() ?? ''
       if (!TEXT_EXTENSIONS.has(ext)) {
-        reqLogger.warn('Skipping non-text sandbox input file', {
+        logger.warn('Skipping non-text sandbox input file', {
           fileId: record.id,
           fileName: record.name,
           ext,
@@ -87,7 +89,7 @@ async function collectSandboxFiles(
         continue
       }
       if (record.size > MAX_FILE_SIZE) {
-        reqLogger.warn('Sandbox input file exceeds size limit', {
+        logger.warn('Sandbox input file exceeds size limit', {
           fileId: record.id,
           fileName: record.name,
           size: record.size,
@@ -116,7 +118,7 @@ async function collectSandboxFiles(
     for (const tableId of inputTables) {
       const table = await getTableById(tableId)
       if (!table) {
-        reqLogger.warn('Sandbox input table not found', { tableId })
+        logger.warn('Sandbox input table not found', { tableId })
         continue
       }
       const { rows } = await queryRows(tableId, workspaceId, { limit: 10000 }, 'sandbox-input')
@@ -146,13 +148,14 @@ export const generateVisualizationServerTool: BaseServerTool<
   VisualizationArgs,
   VisualizationResult
 > = {
-  name: 'generate_visualization',
+  name: GenerateVisualization.id,
 
   async execute(
     params: VisualizationArgs,
     context?: ServerToolContext
   ): Promise<VisualizationResult> {
-    const reqLogger = logger.withMetadata({ messageId: context?.messageId })
+    const withMessageId = (message: string) =>
+      context?.messageId ? `${message} [messageId:${context.messageId}]` : message
 
     if (!context?.userId) {
       throw new Error('Authentication required')
@@ -237,7 +240,7 @@ export const generateVisualizationServerTool: BaseServerTool<
           imageBuffer,
           'image/png'
         )
-        reqLogger.info('Chart image overwritten', {
+        logger.info('Chart image overwritten', {
           fileId: updated.id,
           fileName: updated.name,
           size: imageBuffer.length,
@@ -261,7 +264,7 @@ export const generateVisualizationServerTool: BaseServerTool<
         'image/png'
       )
 
-      reqLogger.info('Chart image saved', {
+      logger.info('Chart image saved', {
         fileId: uploaded.id,
         fileName: uploaded.name,
         size: imageBuffer.length,
@@ -276,7 +279,7 @@ export const generateVisualizationServerTool: BaseServerTool<
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : 'Unknown error'
-      reqLogger.error('Visualization generation failed', { error: msg })
+      logger.error('Visualization generation failed', { error: msg })
       return { success: false, message: `Failed to generate visualization: ${msg}` }
     }
   },
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts
index 7be066d2989..6c4c4988c33 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts
@@ -2,13 +2,18 @@ import { db } from '@sim/db'
 import { workflow as workflowTable } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { eq } from 'drizzle-orm'
+import { EditWorkflow } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
 import { env } from '@/lib/core/config/env'
-import { applyTargetedLayout, getTargetedLayoutImpact } from '@/lib/workflows/autolayout'
+import {
+  applyTargetedLayout,
+  getTargetedLayoutImpact,
+  transferBlockHeights,
+} from '@/lib/workflows/autolayout'
 import {
   DEFAULT_HORIZONTAL_SPACING,
   DEFAULT_VERTICAL_SPACING,
@@ -66,7 +71,7 @@ async function getCurrentWorkflowStateFromDb(
 }
 
 export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown> = {
-  name: 'edit_workflow',
+  name: EditWorkflow.id,
   async execute(params: EditWorkflowParams, context?: ServerToolContext): Promise<unknown> {
     const logger = createLogger('EditWorkflowServerTool')
     const { operations, workflowId, currentUserWorkflow } = params
@@ -87,6 +92,9 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
       throw new Error(authorization.message || 'Unauthorized workflow access')
     }
 
+    const workspaceId = authorization.workflow?.workspaceId ?? undefined
+    const workflowName = authorization.workflow?.name ?? undefined
+
     logger.info('Executing edit_workflow', {
       operationCount: operations.length,
       workflowId,
@@ -119,7 +127,7 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
     if (context?.userId) {
       const { filteredOperations, errors: credErrors } = await preValidateCredentialInputs(
         operations,
-        { userId: context.userId },
+        { userId: context.userId, workspaceId },
         workflowState
       )
       operationsToApply = filteredOperations
@@ -136,20 +144,6 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
     // Add credential validation errors
     validationErrors.push(...credentialErrors)
 
-    let workspaceId: string | undefined
-    let workflowName: string | undefined
-    try {
-      const [workflowRecord] = await db
-        .select({ workspaceId: workflowTable.workspaceId, name: workflowTable.name })
-        .from(workflowTable)
-        .where(eq(workflowTable.id, workflowId))
-        .limit(1)
-      workspaceId = workflowRecord?.workspaceId ?? undefined
-      workflowName = workflowRecord?.name ?? undefined
-    } catch (error) {
-      logger.warn('Failed to get workflow metadata for validation', { error, workflowId })
-    }
-
     // Validate selector IDs exist in the database
     if (context?.userId) {
       try {
@@ -234,17 +228,19 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
     // Persist the workflow state to the database
     const finalWorkflowState = validation.sanitizedState || modifiedWorkflowState
 
-    const { layoutBlockIds, shiftSourceBlockIds } = getTargetedLayoutImpact({
+    const { layoutBlockIds, resizedBlockIds, shiftSourceBlockIds } = getTargetedLayoutImpact({
       before: workflowState,
       after: finalWorkflowState,
     })
 
     let layoutedBlocks = finalWorkflowState.blocks
 
-    if (layoutBlockIds.length > 0 || shiftSourceBlockIds.length > 0) {
+    if (layoutBlockIds.length > 0 || resizedBlockIds.length > 0 || shiftSourceBlockIds.length > 0) {
       try {
+        transferBlockHeights(workflowState.blocks, finalWorkflowState.blocks)
         layoutedBlocks = applyTargetedLayout(finalWorkflowState.blocks, finalWorkflowState.edges, {
           changedBlockIds: layoutBlockIds,
+          resizedBlockIds,
           shiftSourceBlockIds,
           horizontalSpacing: DEFAULT_HORIZONTAL_SPACING,
           verticalSpacing: DEFAULT_VERTICAL_SPACING,
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.test.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.test.ts
index 050c0192036..c5085517182 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.test.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.test.ts
@@ -1,9 +1,12 @@
 /**
  * @vitest-environment node
  */
-import { describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { normalizeConditionRouterIds } from './builders'
-import { validateInputsForBlock } from './validation'
+
+const { mockValidateSelectorIds } = vi.hoisted(() => ({
+  mockValidateSelectorIds: vi.fn(),
+}))
 
 const conditionBlockConfig = {
   type: 'condition',
@@ -12,6 +15,13 @@ const conditionBlockConfig = {
   subBlocks: [{ id: 'conditions', type: 'condition-input' }],
 }
 
+const oauthBlockConfig = {
+  type: 'slack',
+  name: 'Slack',
+  outputs: {},
+  subBlocks: [{ id: 'credential', type: 'oauth-input' }],
+}
+
 const routerBlockConfig = {
   type: 'router_v2',
   name: 'Router',
@@ -23,12 +33,33 @@ vi.mock('@/blocks/registry', () => ({
   getBlock: (type: string) =>
     type === 'condition'
       ? conditionBlockConfig
-      : type === 'router_v2'
-        ? routerBlockConfig
-        : undefined,
+      : type === 'slack'
+        ? oauthBlockConfig
+        : type === 'router_v2'
+          ? routerBlockConfig
+          : undefined,
+}))
+
+vi.mock('@/lib/copilot/validation/selector-validator', () => ({
+  validateSelectorIds: mockValidateSelectorIds,
 }))
 
+vi.mock('@/lib/core/config/feature-flags', () => ({
+  isHosted: false,
+}))
+
+vi.mock('@/providers/utils', () => ({
+  getHostedModels: () => [],
+}))
+
+import { preValidateCredentialInputs, validateInputsForBlock } from './validation'
+
 describe('validateInputsForBlock', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockValidateSelectorIds.mockResolvedValue({ valid: [], invalid: [] })
+  })
+
   it('accepts condition-input arrays with arbitrary item ids', () => {
     const result = validateInputsForBlock(
       'condition',
@@ -88,3 +119,37 @@ describe('normalizeConditionRouterIds', () => {
     expect(normalizeConditionRouterIds('block-1', 'code', input)).toBe(input)
   })
 })
+
+describe('preValidateCredentialInputs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockValidateSelectorIds.mockResolvedValue({ valid: ['shared-cred-1'], invalid: [] })
+  })
+
+  it('passes workspace context when validating shared oauth credentials', async () => {
+    const operations = [
+      {
+        operation_type: 'edit' as const,
+        block_id: 'block-1',
+        params: {
+          type: 'slack',
+          inputs: {
+            credential: 'shared-cred-1',
+          },
+        },
+      },
+    ]
+
+    const result = await preValidateCredentialInputs(operations, {
+      userId: 'user-1',
+      workspaceId: 'workspace-1',
+    })
+
+    expect(mockValidateSelectorIds).toHaveBeenCalledWith('oauth-input', ['shared-cred-1'], {
+      userId: 'user-1',
+      workspaceId: 'workspace-1',
+    })
+    expect(result.filteredOperations[0]?.params?.inputs?.credential).toBe('shared-cred-1')
+    expect(result.errors).toHaveLength(0)
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
index 1847dcbfc4f..efab8a24b3e 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
@@ -792,14 +792,14 @@ export async function validateWorkflowSelectorIds(
 
 /**
  * Pre-validates credential and apiKey inputs in operations before they are applied.
- * - Validates oauth-input (credential) IDs belong to the user
+ * - Validates oauth-input (credential) IDs are accessible to the user in the workflow workspace
  * - Filters out apiKey inputs for hosted models when isHosted is true
  * - Also validates credentials and apiKeys in nestedNodes (blocks inside loop/parallel)
  * Returns validation errors for any removed inputs.
  */
 export async function preValidateCredentialInputs(
   operations: EditWorkflowOperation[],
-  context: { userId: string },
+  context: { userId: string; workspaceId?: string },
   workflowState?: Record<string, unknown>
 ): Promise<{ filteredOperations: EditWorkflowOperation[]; errors: ValidationError[] }> {
   const { isHosted } = await import('@/lib/core/config/feature-flags')
diff --git a/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts b/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts
index d80681f68d2..f561d7b6190 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/get-execution-summary.ts
@@ -2,6 +2,7 @@ import { db } from '@sim/db'
 import { workflow, workflowExecutionLogs } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq, type SQL } from 'drizzle-orm'
+import { GetExecutionSummary } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
 import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
 
@@ -41,7 +42,7 @@ export const getExecutionSummaryServerTool: BaseServerTool<
   GetExecutionSummaryArgs,
   ExecutionSummary[]
 > = {
-  name: 'get_execution_summary',
+  name: GetExecutionSummary.id,
   async execute(
     rawArgs: GetExecutionSummaryArgs,
     context?: ServerToolContext
diff --git a/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts b/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts
index 6d8a6fbc681..2258ec101df 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/get-workflow-logs.ts
@@ -2,8 +2,10 @@ import { db } from '@sim/db'
 import { workflowExecutionLogs } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, desc, eq } from 'drizzle-orm'
+import { GetWorkflowLogs } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { authorizeWorkflowByWorkspacePermission } from '@/lib/workflows/utils'
+import type { TraceSpan } from '@/stores/logs/filters/types'
 
 const logger = createLogger('GetWorkflowLogsServerTool')
 
@@ -24,8 +26,8 @@ interface BlockExecution {
   durationMs: number
   status: 'success' | 'error' | 'skipped'
   errorMessage?: string
-  inputData: any
-  outputData: any
+  inputData: Record<string, unknown>
+  outputData: Record<string, unknown>
   cost?: {
     total: number
     input: number
@@ -35,11 +37,40 @@ interface BlockExecution {
   }
 }
 
-function extractBlockExecutionsFromTraceSpans(traceSpans: any[]): BlockExecution[] {
+interface SimplifiedBlock {
+  id: string
+  name: string
+  startedAt: string
+  endedAt: string
+  durationMs: number
+  output: Record<string, unknown>
+  error: string | undefined
+}
+
+interface SimplifiedExecution {
+  id: string
+  executionId: string
+  status: string
+  startedAt: string
+  endedAt: string | null
+  durationMs: number | null
+  error?: string
+  blocks?: SimplifiedBlock[]
+}
+
+/** Shape of the JSONB executionData column fields we access. */
+interface ExecutionData {
+  traceSpans?: TraceSpan[]
+  errorDetails?: { error?: unknown; message?: unknown }
+  finalOutput?: { error?: unknown }
+  error?: unknown
+}
+
+function extractBlockExecutionsFromTraceSpans(traceSpans: TraceSpan[]): BlockExecution[] {
   const blockExecutions: BlockExecution[] = []
 
-  function processSpan(span: any) {
-    if (span?.blockId) {
+  function processSpan(span: TraceSpan) {
+    if (span.blockId) {
       blockExecutions.push({
         id: span.id,
         blockId: span.blockId,
@@ -49,120 +80,132 @@ function extractBlockExecutionsFromTraceSpans(traceSpans: any[]): BlockExecution
         endedAt: span.endTime,
         durationMs: span.duration || 0,
         status: span.status || 'success',
-        errorMessage: span.output?.error || undefined,
+        errorMessage: span.output?.error as string | undefined,
         inputData: span.input || {},
         outputData: span.output || {},
-        cost: span.cost || undefined,
+        cost: span.cost
+          ? {
+              total: span.cost.total ?? 0,
+              input: span.cost.input ?? 0,
+              output: span.cost.output ?? 0,
+            }
+          : undefined,
       })
     }
-    if (span?.children && Array.isArray(span.children)) {
-      span.children.forEach(processSpan)
-    }
+    span.children?.forEach(processSpan)
   }
 
   traceSpans.forEach(processSpan)
   return blockExecutions
 }
 
-export const getWorkflowLogsServerTool: BaseServerTool<GetWorkflowLogsArgs, any> = {
-  name: 'get_workflow_logs',
-  async execute(rawArgs: GetWorkflowLogsArgs, context?: { userId: string }): Promise<any> {
-    const {
-      workflowId,
-      executionId,
-      limit = 2,
-      includeDetails = false,
-    } = rawArgs || ({} as GetWorkflowLogsArgs)
-
-    if (!workflowId || typeof workflowId !== 'string') {
-      throw new Error('workflowId is required')
-    }
-    if (!context?.userId) {
-      throw new Error('Unauthorized workflow access')
-    }
+export const getWorkflowLogsServerTool: BaseServerTool<GetWorkflowLogsArgs, SimplifiedExecution[]> =
+  {
+    name: GetWorkflowLogs.id,
+    async execute(
+      rawArgs: GetWorkflowLogsArgs,
+      context?: { userId: string }
+    ): Promise<SimplifiedExecution[]> {
+      const {
+        workflowId,
+        executionId,
+        limit = 2,
+        includeDetails = false,
+      } = rawArgs || ({} as GetWorkflowLogsArgs)
+
+      if (!workflowId || typeof workflowId !== 'string') {
+        throw new Error('workflowId is required')
+      }
+      if (!context?.userId) {
+        throw new Error('Unauthorized workflow access')
+      }
 
-    const authorization = await authorizeWorkflowByWorkspacePermission({
-      workflowId,
-      userId: context.userId,
-      action: 'read',
-    })
-    if (!authorization.allowed) {
-      throw new Error(authorization.message || 'Unauthorized workflow access')
-    }
+      const authorization = await authorizeWorkflowByWorkspacePermission({
+        workflowId,
+        userId: context.userId,
+        action: 'read',
+      })
+      if (!authorization.allowed) {
+        throw new Error(authorization.message || 'Unauthorized workflow access')
+      }
 
-    logger.info('Fetching workflow logs', {
-      workflowId,
-      executionId,
-      limit,
-      includeDetails,
-    })
+      logger.info('Fetching workflow logs', {
+        workflowId,
+        executionId,
+        limit,
+        includeDetails,
+      })
 
-    const conditions = [eq(workflowExecutionLogs.workflowId, workflowId)]
-    if (executionId) {
-      conditions.push(eq(workflowExecutionLogs.executionId, executionId))
-    }
+      const conditions = [eq(workflowExecutionLogs.workflowId, workflowId)]
+      if (executionId) {
+        conditions.push(eq(workflowExecutionLogs.executionId, executionId))
+      }
 
-    const executionLogs = await db
-      .select({
-        id: workflowExecutionLogs.id,
-        executionId: workflowExecutionLogs.executionId,
-        status: workflowExecutionLogs.status,
-        level: workflowExecutionLogs.level,
-        trigger: workflowExecutionLogs.trigger,
-        startedAt: workflowExecutionLogs.startedAt,
-        endedAt: workflowExecutionLogs.endedAt,
-        totalDurationMs: workflowExecutionLogs.totalDurationMs,
-        executionData: workflowExecutionLogs.executionData,
-        cost: workflowExecutionLogs.cost,
+      const executionLogs = await db
+        .select({
+          id: workflowExecutionLogs.id,
+          executionId: workflowExecutionLogs.executionId,
+          status: workflowExecutionLogs.status,
+          level: workflowExecutionLogs.level,
+          trigger: workflowExecutionLogs.trigger,
+          startedAt: workflowExecutionLogs.startedAt,
+          endedAt: workflowExecutionLogs.endedAt,
+          totalDurationMs: workflowExecutionLogs.totalDurationMs,
+          executionData: workflowExecutionLogs.executionData,
+          cost: workflowExecutionLogs.cost,
+        })
+        .from(workflowExecutionLogs)
+        .where(and(...conditions))
+        .orderBy(desc(workflowExecutionLogs.startedAt))
+        .limit(executionId ? 1 : limit)
+
+      const simplifiedExecutions: SimplifiedExecution[] = executionLogs.map((log) => {
+        const executionData = log.executionData as ExecutionData
+        const traceSpans = executionData?.traceSpans ?? []
+        const blockExecutions = includeDetails
+          ? extractBlockExecutionsFromTraceSpans(traceSpans)
+          : []
+
+        const simplifiedBlocks: SimplifiedBlock[] = blockExecutions.map((block) => ({
+          id: block.blockId,
+          name: block.blockName,
+          startedAt: block.startedAt,
+          endedAt: block.endedAt,
+          durationMs: block.durationMs,
+          output: block.outputData,
+          error: block.status === 'error' ? block.errorMessage : undefined,
+        }))
+
+        const rawError =
+          executionData?.errorDetails?.error ||
+          executionData?.errorDetails?.message ||
+          executionData?.finalOutput?.error ||
+          executionData?.error ||
+          null
+        const errorMessage = rawError
+          ? typeof rawError === 'string'
+            ? rawError
+            : JSON.stringify(rawError)
+          : undefined
+
+        return {
+          id: log.id,
+          executionId: log.executionId,
+          status: log.status,
+          startedAt: log.startedAt.toISOString(),
+          endedAt: log.endedAt ? log.endedAt.toISOString() : null,
+          durationMs: log.totalDurationMs ?? null,
+          ...(errorMessage ? { error: errorMessage } : {}),
+          ...(simplifiedBlocks.length > 0 ? { blocks: simplifiedBlocks } : {}),
+        }
       })
-      .from(workflowExecutionLogs)
-      .where(and(...conditions))
-      .orderBy(desc(workflowExecutionLogs.startedAt))
-      .limit(executionId ? 1 : limit)
-
-    const simplifiedExecutions = executionLogs.map((log) => {
-      const executionData = log.executionData as any
-      const traceSpans = executionData?.traceSpans || []
-      const blockExecutions = includeDetails ? extractBlockExecutionsFromTraceSpans(traceSpans) : []
-
-      const simplifiedBlocks = blockExecutions.map((block) => ({
-        id: block.blockId,
-        name: block.blockName,
-        startedAt: block.startedAt,
-        endedAt: block.endedAt,
-        durationMs: block.durationMs,
-        output: block.outputData,
-        error: block.status === 'error' ? block.errorMessage : undefined,
-      }))
-
-      const errorMessage =
-        executionData?.errorDetails?.error ||
-        executionData?.errorDetails?.message ||
-        executionData?.finalOutput?.error ||
-        executionData?.error ||
-        null
-
-      return {
-        executionId: log.executionId,
-        status: log.status,
-        startedAt: log.startedAt.toISOString(),
-        endedAt: log.endedAt ? log.endedAt.toISOString() : null,
-        durationMs: log.totalDurationMs ?? null,
-        ...(errorMessage
-          ? {
-              error: typeof errorMessage === 'string' ? errorMessage : JSON.stringify(errorMessage),
-            }
-          : {}),
-        ...(simplifiedBlocks.length > 0 ? { blocks: simplifiedBlocks } : {}),
-      }
-    })
 
-    const resultSize = JSON.stringify(simplifiedExecutions).length
-    logger.info('Workflow logs result prepared', {
-      executionCount: simplifiedExecutions.length,
-      resultSizeKB: Math.round(resultSize / 1024),
-    })
+      const resultSize = JSON.stringify(simplifiedExecutions).length
+      logger.info('Workflow logs result prepared', {
+        executionCount: simplifiedExecutions.length,
+        resultSizeKB: Math.round(resultSize / 1024),
+      })
 
-    return simplifiedExecutions
-  },
-}
+      return simplifiedExecutions
+    },
+  }
diff --git a/apps/sim/lib/copilot/tools/shared/schemas.ts b/apps/sim/lib/copilot/tools/shared/schemas.ts
deleted file mode 100644
index c59200e8466..00000000000
--- a/apps/sim/lib/copilot/tools/shared/schemas.ts
+++ /dev/null
@@ -1,274 +0,0 @@
-import { z } from 'zod'
-
-// Generic envelope used by client to validate API responses
-export const ExecuteResponseSuccessSchema = z.object({
-  success: z.literal(true),
-  result: z.unknown(),
-})
-export type ExecuteResponseSuccess = z.infer<typeof ExecuteResponseSuccessSchema>
-
-// get_blocks_metadata
-export const GetBlocksMetadataInput = z.object({ blockIds: z.array(z.string()).min(1) })
-export const GetBlocksMetadataResult = z.object({ metadata: z.record(z.any()) })
-export type GetBlocksMetadataResultType = z.infer<typeof GetBlocksMetadataResult>
-
-// get_trigger_blocks
-export const GetTriggerBlocksInput = z.object({})
-export const GetTriggerBlocksResult = z.object({
-  triggerBlockIds: z.array(z.string()),
-})
-export type GetTriggerBlocksResultType = z.infer<typeof GetTriggerBlocksResult>
-
-// knowledge_base - shared schema used by client tool, server tool, and registry
-export const KnowledgeBaseArgsSchema = z.object({
-  operation: z.enum([
-    'create',
-    'get',
-    'query',
-    'update',
-    'delete',
-    'add_file',
-    'delete_document',
-    'update_document',
-    'list_tags',
-    'create_tag',
-    'update_tag',
-    'delete_tag',
-    'get_tag_usage',
-    'add_connector',
-    'update_connector',
-    'delete_connector',
-    'sync_connector',
-  ]),
-  args: z
-    .object({
-      /** Name of the knowledge base (required for create) */
-      name: z.string().optional(),
-      /** Description of the knowledge base (optional for create) */
-      description: z.string().optional(),
-      /** Workspace ID to associate with (required for create, optional for list) */
-      workspaceId: z.string().optional(),
-      /** Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage, add_connector) */
-      knowledgeBaseId: z.string().optional(),
-      /** Workspace file ID to add as a document (required for add_file). */
-      fileId: z.string().optional(),
-      /** Legacy workspace file reference for add_file. Prefer fileId. */
-      filePath: z.string().optional(),
-      /** Search query text (required for query) */
-      query: z.string().optional(),
-      /** Number of results to return (optional for query, defaults to 5) */
-      topK: z.number().min(1).max(50).optional(),
-      /** Chunking configuration (optional for create) */
-      chunkingConfig: z
-        .object({
-          maxSize: z.number().min(100).max(4000).default(1024),
-          minSize: z.number().min(1).max(2000).default(1),
-          overlap: z.number().min(0).max(500).default(200),
-        })
-        .optional(),
-      /** Tag definition ID (required for update_tag, delete_tag) */
-      tagDefinitionId: z.string().optional(),
-      /** Tag display name (required for create_tag, optional for update_tag) */
-      tagDisplayName: z.string().optional(),
-      /** Tag field type: text, number, date, boolean (optional for create_tag, defaults to text) */
-      tagFieldType: z.enum(['text', 'number', 'date', 'boolean']).optional(),
-      /** Connector type from registry, e.g. "confluence" (required for add_connector) */
-      connectorType: z.string().optional(),
-      /** OAuth credential ID from environment/credentials.json (required for OAuth connectors) */
-      credentialId: z.string().optional(),
-      /** API key for API key-based connectors (required for API key connectors) */
-      apiKey: z.string().optional(),
-      /** Connector-specific config matching the schema in knowledgebases/connectors/{type}.json */
-      sourceConfig: z.record(z.unknown()).optional(),
-      /** Sync interval: 60, 360, 1440, 10080, or 0 for manual only (optional for add_connector, defaults to 1440) */
-      syncIntervalMinutes: z.number().int().min(0).optional(),
-      /** Connector ID (required for update_connector, delete_connector, sync_connector) */
-      connectorId: z.string().optional(),
-      /** Connector status: "active" or "paused" (optional for update_connector) */
-      connectorStatus: z.enum(['active', 'paused']).optional(),
-      /** Tag definition IDs to disable (optional for add_connector) */
-      disabledTagIds: z.array(z.string()).optional(),
-      /** Document ID (required for delete_document, update_document) */
-      documentId: z.string().optional(),
-      /** Enable/disable a document (optional for update_document) */
-      enabled: z.boolean().optional(),
-      /** New filename for a document (optional for update_document) */
-      filename: z.string().optional(),
-    })
-    .optional(),
-})
-export type KnowledgeBaseArgs = z.infer<typeof KnowledgeBaseArgsSchema>
-
-export const KnowledgeBaseResultSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  data: z.any().optional(),
-})
-export type KnowledgeBaseResult = z.infer<typeof KnowledgeBaseResultSchema>
-
-// user_table - shared schema used by server tool and registry
-export const UserTableArgsSchema = z.object({
-  operation: z.enum([
-    'create',
-    'create_from_file',
-    'import_file',
-    'get',
-    'get_schema',
-    'delete',
-    'insert_row',
-    'batch_insert_rows',
-    'get_row',
-    'query_rows',
-    'update_row',
-    'delete_row',
-    'update_rows_by_filter',
-    'delete_rows_by_filter',
-    'batch_update_rows',
-    'batch_delete_rows',
-    'add_column',
-    'rename_column',
-    'delete_column',
-    'update_column',
-    'rename',
-  ]),
-  args: z
-    .object({
-      name: z.string().optional(),
-      description: z.string().optional(),
-      schema: z.any().optional(),
-      tableId: z.string().optional(),
-      rowId: z.string().optional(),
-      data: z.record(z.any()).optional(),
-      rows: z.array(z.record(z.any())).optional(),
-      updates: z.array(z.object({ rowId: z.string(), data: z.record(z.any()) })).optional(),
-      rowIds: z.array(z.string()).optional(),
-      values: z.record(z.any()).optional(),
-      filter: z.any().optional(),
-      sort: z.record(z.enum(['asc', 'desc'])).optional(),
-      limit: z.number().optional(),
-      offset: z.number().optional(),
-      fileId: z.string().optional(),
-      filePath: z.string().optional(),
-      column: z
-        .object({
-          name: z.string(),
-          type: z.string(),
-          unique: z.boolean().optional(),
-          position: z.number().optional(),
-        })
-        .optional(),
-      columnName: z.string().optional(),
-      columnNames: z.array(z.string()).optional(),
-      newName: z.string().optional(),
-      newType: z.string().optional(),
-      unique: z.boolean().optional(),
-    })
-    .optional(),
-})
-export type UserTableArgs = z.infer<typeof UserTableArgsSchema>
-
-export const UserTableResultSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  data: z.any().optional(),
-})
-export type UserTableResult = z.infer<typeof UserTableResultSchema>
-
-// workspace_file - shared schema used by server tool and Go catalog
-export const WorkspaceFileArgsSchema = z.object({
-  operation: z.enum(['write', 'update', 'delete', 'rename', 'patch']),
-  args: z
-    .object({
-      fileId: z.string().optional(),
-      fileName: z.string().optional(),
-      content: z.string().optional(),
-      contentType: z.string().optional(),
-      workspaceId: z.string().optional(),
-      newName: z.string().optional(),
-      edits: z
-        .array(z.object({ search: z.string(), replace: z.string() }))
-        .describe(
-          'List of search/replace pairs applied sequentially — each edit operates on the result of the previous one. Search strings must be unique within the file.'
-        )
-        .optional(),
-    })
-    .optional(),
-})
-export type WorkspaceFileArgs = z.infer<typeof WorkspaceFileArgsSchema>
-
-export const WorkspaceFileResultSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  data: z.any().optional(),
-})
-export type WorkspaceFileResult = z.infer<typeof WorkspaceFileResultSchema>
-
-export const GetBlockOutputsInput = z.object({
-  blockIds: z.array(z.string()).optional(),
-})
-export const GetBlockOutputsResult = z.object({
-  blocks: z.array(
-    z.object({
-      blockId: z.string(),
-      blockName: z.string(),
-      blockType: z.string(),
-      triggerMode: z.boolean().optional(),
-      outputs: z.array(z.string()),
-      insideSubflowOutputs: z.array(z.string()).optional(),
-      outsideSubflowOutputs: z.array(z.string()).optional(),
-    })
-  ),
-  variables: z
-    .array(
-      z.object({
-        id: z.string(),
-        name: z.string(),
-        type: z.string(),
-        tag: z.string(),
-      })
-    )
-    .optional(),
-})
-export type GetBlockOutputsInputType = z.infer<typeof GetBlockOutputsInput>
-export type GetBlockOutputsResultType = z.infer<typeof GetBlockOutputsResult>
-
-export const GetBlockUpstreamReferencesInput = z.object({
-  blockIds: z.array(z.string()).min(1),
-})
-export const GetBlockUpstreamReferencesResult = z.object({
-  results: z.array(
-    z.object({
-      blockId: z.string(),
-      blockName: z.string(),
-      insideSubflows: z
-        .array(
-          z.object({
-            blockId: z.string(),
-            blockName: z.string(),
-            blockType: z.string(),
-          })
-        )
-        .optional(),
-      accessibleBlocks: z.array(
-        z.object({
-          blockId: z.string(),
-          blockName: z.string(),
-          blockType: z.string(),
-          triggerMode: z.boolean().optional(),
-          outputs: z.array(z.string()),
-          accessContext: z.enum(['inside', 'outside']).optional(),
-        })
-      ),
-      variables: z.array(
-        z.object({
-          id: z.string(),
-          name: z.string(),
-          type: z.string(),
-          tag: z.string(),
-        })
-      ),
-    })
-  ),
-})
-export type GetBlockUpstreamReferencesInputType = z.infer<typeof GetBlockUpstreamReferencesInput>
-export type GetBlockUpstreamReferencesResultType = z.infer<typeof GetBlockUpstreamReferencesResult>
diff --git a/apps/sim/lib/copilot/workflow-tools.ts b/apps/sim/lib/copilot/tools/workflow-tools.ts
similarity index 87%
rename from apps/sim/lib/copilot/workflow-tools.ts
rename to apps/sim/lib/copilot/tools/workflow-tools.ts
index ecfba90cebf..fc750614dfb 100644
--- a/apps/sim/lib/copilot/workflow-tools.ts
+++ b/apps/sim/lib/copilot/tools/workflow-tools.ts
@@ -1,4 +1,4 @@
-export const WORKFLOW_TOOL_NAMES = [
+const WORKFLOW_TOOL_NAMES = [
   'run_workflow',
   'run_workflow_until_block',
   'run_block',
diff --git a/apps/sim/lib/copilot/types.ts b/apps/sim/lib/copilot/types.ts
deleted file mode 100644
index 031e835318a..00000000000
--- a/apps/sim/lib/copilot/types.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { CopilotToolCall, ToolState } from '@/stores/panel'
-
-export type NotificationStatus =
-  | 'pending'
-  | 'success'
-  | 'error'
-  | 'accepted'
-  | 'rejected'
-  | 'background'
-  | 'cancelled'
-
-export type { CopilotToolCall, ToolState }
-
-export interface AvailableModel {
-  id: string
-  friendlyName: string
-  provider: string
-}
diff --git a/apps/sim/lib/copilot/utils.ts b/apps/sim/lib/copilot/utils.ts
deleted file mode 100644
index cb6b25979d8..00000000000
--- a/apps/sim/lib/copilot/utils.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import type { NextRequest } from 'next/server'
-import { env } from '@/lib/core/config/env'
-import { safeCompare } from '@/lib/core/security/encryption'
-
-export function checkInternalApiKey(req: NextRequest) {
-  const apiKey = req.headers.get('x-api-key')
-  const expectedApiKey = env.INTERNAL_API_SECRET
-
-  if (!expectedApiKey) {
-    return { success: false, error: 'Internal API key not configured' }
-  }
-
-  if (!apiKey) {
-    return { success: false, error: 'API key required' }
-  }
-
-  if (!safeCompare(apiKey, expectedApiKey)) {
-    return { success: false, error: 'Invalid API key' }
-  }
-
-  return { success: true }
-}
diff --git a/apps/sim/lib/copilot/validation/selector-validator.test.ts b/apps/sim/lib/copilot/validation/selector-validator.test.ts
new file mode 100644
index 00000000000..8774104a7ae
--- /dev/null
+++ b/apps/sim/lib/copilot/validation/selector-validator.test.ts
@@ -0,0 +1,131 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockDbSelect } = vi.hoisted(() => ({
+  mockDbSelect: vi.fn(),
+}))
+
+vi.mock('@sim/db', () => ({
+  db: {
+    select: (...args: unknown[]) => mockDbSelect(...args),
+  },
+}))
+
+vi.mock('@sim/db/schema', () => ({
+  account: {
+    id: 'account.id',
+    userId: 'account.userId',
+    providerId: 'account.providerId',
+  },
+  credential: {
+    id: 'credential.id',
+    accountId: 'credential.accountId',
+    displayName: 'credential.displayName',
+    providerId: 'credential.providerId',
+    workspaceId: 'credential.workspaceId',
+    type: 'credential.type',
+  },
+  credentialMember: {
+    credentialId: 'credentialMember.credentialId',
+    userId: 'credentialMember.userId',
+    status: 'credentialMember.status',
+  },
+  document: {
+    id: 'document.id',
+    userExcluded: 'document.userExcluded',
+    archivedAt: 'document.archivedAt',
+    deletedAt: 'document.deletedAt',
+  },
+  knowledgeBase: {
+    id: 'knowledgeBase.id',
+    deletedAt: 'knowledgeBase.deletedAt',
+    workspaceId: 'knowledgeBase.workspaceId',
+  },
+  mcpServers: {
+    id: 'mcpServers.id',
+    enabled: 'mcpServers.enabled',
+    deletedAt: 'mcpServers.deletedAt',
+    workspaceId: 'mcpServers.workspaceId',
+  },
+  workflow: {
+    id: 'workflow.id',
+    archivedAt: 'workflow.archivedAt',
+  },
+}))
+
+vi.mock('@sim/logger', () => ({
+  createLogger: () => ({
+    warn: vi.fn(),
+    error: vi.fn(),
+  }),
+}))
+
+vi.mock('drizzle-orm', () => ({
+  and: vi.fn((...args: unknown[]) => ({ type: 'and', args })),
+  eq: vi.fn((...args: unknown[]) => ({ type: 'eq', args })),
+  inArray: vi.fn((...args: unknown[]) => ({ type: 'inArray', args })),
+  isNull: vi.fn((field: unknown) => ({ type: 'isNull', field })),
+  or: vi.fn((...args: unknown[]) => ({ type: 'or', args })),
+}))
+
+import { validateSelectorIds } from './selector-validator'
+
+function createSelectChain(result: unknown) {
+  const chain: Record<string, unknown> = {}
+  Object.assign(chain, {
+    from: vi.fn().mockReturnValue(chain),
+    innerJoin: vi.fn().mockReturnValue(chain),
+    leftJoin: vi.fn().mockReturnValue(chain),
+    where: vi.fn().mockResolvedValue(result),
+  })
+  return chain
+}
+
+describe('validateSelectorIds', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('accepts shared workspace credential ids and legacy account ids for oauth-input', async () => {
+    mockDbSelect.mockReturnValueOnce(
+      createSelectChain([{ credentialId: 'cred-1', accountId: 'acct-1' }])
+    )
+
+    const result = await validateSelectorIds('oauth-input', ['cred-1', 'acct-1'], {
+      userId: 'user-1',
+      workspaceId: 'workspace-1',
+    })
+
+    expect(result).toEqual({
+      valid: ['cred-1', 'acct-1'],
+      invalid: [],
+    })
+    expect(mockDbSelect).toHaveBeenCalledTimes(1)
+  })
+
+  it('reports accessible workspace credentials in warnings for invalid oauth-input ids', async () => {
+    mockDbSelect.mockReturnValueOnce(createSelectChain([])).mockReturnValueOnce(
+      createSelectChain([
+        {
+          id: 'cred-2',
+          displayName: 'Shared Gmail',
+          accountId: 'acct-2',
+          credentialProviderId: null,
+          accountProviderId: 'google-email',
+        },
+      ])
+    )
+
+    const result = await validateSelectorIds('oauth-input', 'missing-cred', {
+      userId: 'user-1',
+      workspaceId: 'workspace-1',
+    })
+
+    expect(result.valid).toEqual([])
+    expect(result.invalid).toEqual(['missing-cred'])
+    expect(result.warning).toContain('Accessible workspace credentials:')
+    expect(result.warning).toContain('Shared Gmail [cred-2]')
+  })
+})
diff --git a/apps/sim/lib/copilot/validation/selector-validator.ts b/apps/sim/lib/copilot/validation/selector-validator.ts
index 4158d4add6a..65123904342 100644
--- a/apps/sim/lib/copilot/validation/selector-validator.ts
+++ b/apps/sim/lib/copilot/validation/selector-validator.ts
@@ -1,7 +1,15 @@
 import { db } from '@sim/db'
-import { account, document, knowledgeBase, mcpServers, workflow } from '@sim/db/schema'
+import {
+  account,
+  credential,
+  credentialMember,
+  document,
+  knowledgeBase,
+  mcpServers,
+  workflow,
+} from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, eq, inArray, isNull } from 'drizzle-orm'
+import { and, eq, inArray, isNull, or } from 'drizzle-orm'
 
 const logger = createLogger('SelectorValidator')
 
@@ -33,7 +41,95 @@ export async function validateSelectorIds(
   try {
     switch (selectorType) {
       case 'oauth-input': {
-        // Credentials must belong to the user
+        if (context.workspaceId) {
+          // In workspace workflows, oauth-input values are workspace credential IDs.
+          // Accept both current credential IDs and legacy account IDs when the user
+          // has active membership to the workspace credential.
+          const results = await db
+            .select({ credentialId: credential.id, accountId: credential.accountId })
+            .from(credential)
+            .innerJoin(
+              credentialMember,
+              and(
+                eq(credentialMember.credentialId, credential.id),
+                eq(credentialMember.userId, context.userId),
+                eq(credentialMember.status, 'active')
+              )
+            )
+            .where(
+              and(
+                eq(credential.workspaceId, context.workspaceId),
+                inArray(credential.type, ['oauth', 'service_account']),
+                or(inArray(credential.id, idsArray), inArray(credential.accountId, idsArray))
+              )
+            )
+
+          existingIds = Array.from(
+            new Set(
+              results.flatMap((result) => {
+                const matches: string[] = []
+                if (idsArray.includes(result.credentialId)) {
+                  matches.push(result.credentialId)
+                }
+                if (result.accountId && idsArray.includes(result.accountId)) {
+                  matches.push(result.accountId)
+                }
+                return matches
+              })
+            )
+          )
+
+          const existingSet = new Set(existingIds)
+          const invalidIds = idsArray.filter((id) => !existingSet.has(id))
+          if (invalidIds.length > 0) {
+            const allAccessibleCredentials = await db
+              .select({
+                id: credential.id,
+                displayName: credential.displayName,
+                accountId: credential.accountId,
+                credentialProviderId: credential.providerId,
+                accountProviderId: account.providerId,
+              })
+              .from(credential)
+              .leftJoin(account, eq(credential.accountId, account.id))
+              .innerJoin(
+                credentialMember,
+                and(
+                  eq(credentialMember.credentialId, credential.id),
+                  eq(credentialMember.userId, context.userId),
+                  eq(credentialMember.status, 'active')
+                )
+              )
+              .where(
+                and(
+                  eq(credential.workspaceId, context.workspaceId),
+                  inArray(credential.type, ['oauth', 'service_account'])
+                )
+              )
+
+            const availableCredentials = allAccessibleCredentials
+              .map((cred) => {
+                const providerId =
+                  cred.accountProviderId || cred.credentialProviderId || 'unknown-provider'
+                const legacyId = cred.accountId ? `, legacy ${cred.accountId}` : ''
+                return `${cred.displayName} [${cred.id}] (${providerId}${legacyId})`
+              })
+              .join(', ')
+            const noCredentialsMessage = 'User has no accessible credentials in this workspace.'
+
+            return {
+              valid: existingIds,
+              invalid: invalidIds,
+              warning:
+                allAccessibleCredentials.length > 0
+                  ? `Accessible workspace credentials: ${availableCredentials}`
+                  : noCredentialsMessage,
+            }
+          }
+          break
+        }
+
+        // Fallback for older callers that still validate against legacy account IDs.
         const results = await db
           .select({ id: account.id })
           .from(account)
diff --git a/apps/sim/lib/copilot/vfs/file-reader.ts b/apps/sim/lib/copilot/vfs/file-reader.ts
index d3fd77aaf3a..00f2e2dc55e 100644
--- a/apps/sim/lib/copilot/vfs/file-reader.ts
+++ b/apps/sim/lib/copilot/vfs/file-reader.ts
@@ -31,6 +31,16 @@ function getExtension(filename: string): string {
   return dot >= 0 ? filename.slice(dot + 1).toLowerCase() : ''
 }
 
+function detectImageMime(buf: Buffer, claimed: string): string {
+  if (buf.length < 12) return claimed
+  if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) return 'image/jpeg'
+  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) return 'image/png'
+  if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46) return 'image/gif'
+  if (buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50)
+    return 'image/webp'
+  return claimed
+}
+
 export interface FileReadResult {
   content: string
   totalLines: number
@@ -59,14 +69,15 @@ export async function readFileRecord(record: WorkspaceFileRecord): Promise<FileR
         }
       }
       const buffer = await downloadWorkspaceFile(record)
+      const mime = detectImageMime(buffer, record.type)
       return {
-        content: `Image: ${record.name} (${(record.size / 1024).toFixed(1)}KB, ${record.type})`,
+        content: `Image: ${record.name} (${(record.size / 1024).toFixed(1)}KB, ${mime})`,
         totalLines: 1,
         attachment: {
           type: 'image',
           source: {
             type: 'base64',
-            media_type: record.type,
+            media_type: mime,
             data: buffer.toString('base64'),
           },
         },
diff --git a/apps/sim/lib/copilot/vfs/operations.ts b/apps/sim/lib/copilot/vfs/operations.ts
index f1704ab81a9..1456c11b2c6 100644
--- a/apps/sim/lib/copilot/vfs/operations.ts
+++ b/apps/sim/lib/copilot/vfs/operations.ts
@@ -226,8 +226,10 @@ export function read(
   const totalLines = lines.length
 
   if (offset !== undefined || limit !== undefined) {
-    const start = offset ?? 0
-    const end = limit !== undefined ? start + limit : lines.length
+    const rawStart = Number.isFinite(offset) ? (offset as number) : 0
+    const start = Math.max(0, Math.min(totalLines, rawStart))
+    const rawEnd = limit !== undefined ? start + Math.max(0, limit) : totalLines
+    const end = Math.max(start, Math.min(totalLines, rawEnd))
     return {
       content: lines.slice(start, end).join('\n'),
       totalLines,
diff --git a/apps/sim/lib/copilot/vfs/serializers.ts b/apps/sim/lib/copilot/vfs/serializers.ts
index 524e8567e01..04e6ff5a533 100644
--- a/apps/sim/lib/copilot/vfs/serializers.ts
+++ b/apps/sim/lib/copilot/vfs/serializers.ts
@@ -1,4 +1,4 @@
-import { getCopilotToolDescription } from '@/lib/copilot/tool-descriptions'
+import { getCopilotToolDescription } from '@/lib/copilot/tools/descriptions'
 import { isHosted } from '@/lib/core/config/feature-flags'
 import { isSubBlockHidden } from '@/lib/workflows/subblocks/visibility'
 import type { BlockConfig, SubBlockConfig } from '@/blocks/types'
@@ -12,6 +12,7 @@ export function serializeWorkflowMeta(wf: {
   id: string
   name: string
   description?: string | null
+  folderId?: string | null
   isDeployed: boolean
   deployedAt?: Date | null
   runCount: number
@@ -24,6 +25,7 @@ export function serializeWorkflowMeta(wf: {
       id: wf.id,
       name: wf.name,
       description: wf.description || undefined,
+      folderId: wf.folderId || undefined,
       isDeployed: wf.isDeployed,
       deployedAt: wf.deployedAt?.toISOString(),
       runCount: wf.runCount,
@@ -559,7 +561,7 @@ export function serializeDeployments(data: DeploymentData): string {
     result.api = {
       isDeployed: true,
       deployedAt: data.deployedAt?.toISOString(),
-      apiEndpoint: `/api/workflows/${data.workflowId}/run`,
+      apiEndpoint: `/api/workflows/${data.workflowId}/execute`,
       ...(data.api ? { version: data.api.version } : {}),
     }
   }
diff --git a/apps/sim/lib/copilot/vfs/workspace-vfs.ts b/apps/sim/lib/copilot/vfs/workspace-vfs.ts
index e43e5b03ec6..530e3f3054c 100644
--- a/apps/sim/lib/copilot/vfs/workspace-vfs.ts
+++ b/apps/sim/lib/copilot/vfs/workspace-vfs.ts
@@ -10,13 +10,15 @@ import {
   mcpServers as mcpServersTable,
   workflowDeploymentVersion,
   workflowExecutionLogs,
+  workflowFolder,
   workflowMcpServer,
   workflowMcpTool,
   workflowSchedule,
 } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { and, desc, eq, isNull, ne } from 'drizzle-orm'
+import { and, desc, eq, isNotNull, isNull, ne } from 'drizzle-orm'
 import { listApiKeys } from '@/lib/api-key/service'
+import { buildWorkspaceMd, type WorkspaceMdData } from '@/lib/copilot/chat/workspace-context'
 import { type FileReadResult, readFileRecord } from '@/lib/copilot/vfs/file-reader'
 import { normalizeVfsSegment } from '@/lib/copilot/vfs/normalize-segment'
 import type { DirEntry, GrepMatch, GrepOptions, ReadResult } from '@/lib/copilot/vfs/operations'
@@ -49,7 +51,6 @@ import {
   serializeVersions,
   serializeWorkflowMeta,
 } from '@/lib/copilot/vfs/serializers'
-import { buildWorkspaceMd, type WorkspaceMdData } from '@/lib/copilot/workspace-context'
 import {
   getAccessibleEnvCredentials,
   getAccessibleOAuthCredentials,
@@ -66,7 +67,7 @@ import { listCustomTools } from '@/lib/workflows/custom-tools/operations'
 import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import { listSkills } from '@/lib/workflows/skills/operations'
-import { listWorkflows } from '@/lib/workflows/utils'
+import { listFolders, listWorkflows } from '@/lib/workflows/utils'
 import {
   assertActiveWorkspaceAccess,
   getUsersWithPermissions,
@@ -118,6 +119,10 @@ function getStaticComponentFiles(): Map<string, string> {
 
   const latestTools = getLatestVersionTools(toolRegistry)
   let integrationCount = 0
+
+  const oauthServices = new Map<string, { provider: string; operations: string[] }>()
+  const apiKeyServices = new Map<string, { params: string[]; operations: string[] }>()
+
   for (const [toolId, tool] of Object.entries(latestTools)) {
     const baseName = stripVersionSuffix(toolId)
     const service = toolToService.get(toolId) ?? toolToService.get(baseName)
@@ -132,8 +137,39 @@ function getStaticComponentFiles(): Map<string, string> {
     const path = `components/integrations/${service}/${operation}.json`
     files.set(path, serializeIntegrationSchema(tool))
     integrationCount++
+
+    if (tool.oauth?.required) {
+      const existing = oauthServices.get(service)
+      if (existing) {
+        existing.operations.push(operation)
+      } else {
+        oauthServices.set(service, { provider: tool.oauth.provider, operations: [operation] })
+      }
+    } else if (tool.hosting?.apiKeyParam) {
+      const existing = apiKeyServices.get(service)
+      if (existing) {
+        if (!existing.params.includes(tool.hosting.apiKeyParam)) {
+          existing.params.push(tool.hosting.apiKeyParam)
+        }
+        existing.operations.push(operation)
+      } else {
+        apiKeyServices.set(service, {
+          params: [tool.hosting.apiKeyParam],
+          operations: [operation],
+        })
+      }
+    }
   }
 
+  files.set(
+    'environment/oauth-integrations.json',
+    JSON.stringify(Object.fromEntries(oauthServices), null, 2)
+  )
+  files.set(
+    'environment/api-key-integrations.json',
+    JSON.stringify(Object.fromEntries(apiKeyServices), null, 2)
+  )
+
   files.set(
     'components/blocks/loop.json',
     JSON.stringify(
@@ -262,10 +298,11 @@ function getStaticComponentFiles(): Map<string, string> {
  *
  * Structure:
  *   WORKSPACE.md                         — workspace identity, members, inventory (auto-generated)
- *   workflows/{name}/meta.json
+ *   workflows/{name}/meta.json            (root-level workflows)
  *   workflows/{name}/state.json          (sanitized blocks with embedded connections)
  *   workflows/{name}/executions.json
  *   workflows/{name}/deployment.json
+ *   workflows/{folder}/{name}/...        (workflows inside folders, nested folders supported)
  *   knowledgebases/{name}/meta.json
  *   knowledgebases/{name}/documents.json
  *   knowledgebases/{name}/connectors.json
@@ -344,7 +381,8 @@ export class WorkspaceVFS {
         knowledgeBases: kbSummary,
         tables: tblSummary,
         files: fileSummary,
-        credentials: envSummary,
+        oauthIntegrations: envSummary.oauthIntegrations,
+        envVariables: envSummary.envVariables,
         tasks: taskSummary,
         customTools: toolsSummary,
         mcpServers: mcpServersSummary,
@@ -353,6 +391,8 @@ export class WorkspaceVFS {
       })
     )
 
+    await this.materializeRecentlyDeleted(workspaceId, userId)
+
     for (const [path, content] of getStaticComponentFiles()) {
       this.files.set(path, content)
     }
@@ -364,16 +404,32 @@ export class WorkspaceVFS {
     })
   }
 
+  private activeFiles(): Map<string, string> {
+    const filtered = new Map<string, string>()
+    for (const [key, value] of this.files) {
+      if (!key.startsWith('recently-deleted/')) {
+        filtered.set(key, value)
+      }
+    }
+    return filtered
+  }
+
+  private filesForPath(path?: string): Map<string, string> {
+    if (path?.startsWith('recently-deleted')) return this.files
+    return this.activeFiles()
+  }
+
   grep(
     pattern: string,
     path?: string,
     options?: GrepOptions
   ): GrepMatch[] | string[] | ops.GrepCountEntry[] {
-    return ops.grep(this.files, pattern, path, options)
+    return ops.grep(this.filesForPath(path), pattern, path, options)
   }
 
   glob(pattern: string): string[] {
-    return ops.glob(this.files, pattern)
+    const target = pattern.startsWith('recently-deleted') ? this.files : this.activeFiles()
+    return ops.glob(target, pattern)
   }
 
   read(path: string, offset?: number, limit?: number): ReadResult | null {
@@ -381,7 +437,7 @@ export class WorkspaceVFS {
   }
 
   list(path: string): DirEntry[] {
-    return ops.list(this.files, path)
+    return ops.list(this.filesForPath(path), path)
   }
 
   suggestSimilar(missingPath: string, max?: number): string[] {
@@ -394,15 +450,22 @@ export class WorkspaceVFS {
    * Returns null if the path doesn't match `files/{name}` / `files/by-id/{id}` or the file isn't found.
    */
   async readFileContent(path: string): Promise<FileReadResult | null> {
-    const match = path.match(/^files\/(.+?)(?:\/content)?$/)
+    const deletedMatch = path.match(/^recently-deleted\/files\/(.+?)(?:\/content)?$/)
+    const activeMatch = path.match(/^files\/(.+?)(?:\/content)?$/)
+    const match = deletedMatch || activeMatch
     if (!match) return null
-    const fileName = match[1]
+    const fileReference = path
+      .replace(/^recently-deleted\//, '')
+      .replace(/\/content$/, '')
+      .replace(/^\/+/, '')
+
+    if (fileReference.endsWith('/meta.json') || path.endsWith('/meta.json')) return null
 
-    if (fileName.endsWith('/meta.json') || path.endsWith('/meta.json')) return null
+    const scope = deletedMatch ? 'archived' : 'active'
 
     try {
-      const files = await listWorkspaceFiles(this._workspaceId)
-      const record = findWorkspaceFileRecord(files, fileName)
+      const files = await listWorkspaceFiles(this._workspaceId, { scope })
+      const record = findWorkspaceFileRecord(files, fileReference)
       if (!record) return null
       return readFileRecord(record)
     } catch (err) {
@@ -415,20 +478,70 @@ export class WorkspaceVFS {
     }
   }
 
+  /**
+   * Build a map from folderId to its full VFS path segment (e.g. "My Folder/Sub Folder").
+   * Handles nested folders via parentId traversal.
+   */
+  private buildFolderPaths(
+    folders: Array<{ folderId: string; folderName: string; parentId: string | null }>
+  ): Map<string, string> {
+    const folderMap = new Map<string, { name: string; parentId: string | null }>()
+    for (const f of folders) {
+      folderMap.set(f.folderId, { name: f.folderName, parentId: f.parentId })
+    }
+
+    const cache = new Map<string, string>()
+    const resolve = (id: string): string => {
+      if (cache.has(id)) return cache.get(id)!
+      const folder = folderMap.get(id)
+      if (!folder) return ''
+      const parentPath = folder.parentId ? resolve(folder.parentId) : ''
+      const path = parentPath
+        ? `${parentPath}/${sanitizeName(folder.name)}`
+        : sanitizeName(folder.name)
+      cache.set(id, path)
+      return path
+    }
+
+    for (const id of folderMap.keys()) {
+      resolve(id)
+    }
+    return cache
+  }
+
   /**
    * Materialize all workflows using the shared listWorkflows function.
+   * Workflows are nested under their folder paths in the VFS:
+   *   workflows/{folder}/{name}/  (if in a folder)
+   *   workflows/{name}/           (if at workspace root)
    * Returns a summary for WORKSPACE.md generation.
    */
   private async materializeWorkflows(
     workspaceId: string,
     _userId: string
   ): Promise<WorkspaceMdData['workflows']> {
-    const workflowRows = await listWorkflows(workspaceId)
+    const [workflowRows, folderRows] = await Promise.all([
+      listWorkflows(workspaceId),
+      listFolders(workspaceId),
+    ])
+
+    const folderPaths = this.buildFolderPaths(folderRows)
+
+    // Register all folders in the VFS so empty folders are discoverable.
+    for (const { folderId } of folderRows) {
+      const folderPath = folderPaths.get(folderId)
+      if (folderPath) {
+        this.files.set(`workflows/${folderPath}/.folder`, '')
+      }
+    }
 
     await Promise.all(
       workflowRows.map(async (wf) => {
         const safeName = sanitizeName(wf.name)
-        const prefix = `workflows/${safeName}/`
+        const folderPath = wf.folderId ? folderPaths.get(wf.folderId) : null
+        const prefix = folderPath
+          ? `workflows/${folderPath}/${safeName}/`
+          : `workflows/${safeName}/`
 
         this.files.set(`${prefix}meta.json`, serializeWorkflowMeta(wf))
 
@@ -506,6 +619,7 @@ export class WorkspaceVFS {
       description: wf.description,
       isDeployed: wf.isDeployed,
       lastRunAt: wf.lastRunAt,
+      folderPath: wf.folderId ? (folderPaths.get(wf.folderId) ?? null) : null,
     }))
   }
 
@@ -689,7 +803,7 @@ export class WorkspaceVFS {
         )
       }
 
-      return files.map((f) => ({ name: f.name, type: f.type, size: f.size }))
+      return files.map((f) => ({ id: f.id, name: f.name, type: f.type, size: f.size }))
     } catch (err) {
       logger.warn('Failed to materialize files', {
         workspaceId,
@@ -722,7 +836,7 @@ export class WorkspaceVFS {
           isActive: chatTable.isActive,
         })
         .from(chatTable)
-        .where(eq(chatTable.workflowId, workflowId)),
+        .where(and(eq(chatTable.workflowId, workflowId), isNull(chatTable.archivedAt))),
       db
         .select({
           id: form.id,
@@ -735,7 +849,7 @@ export class WorkspaceVFS {
           isActive: form.isActive,
         })
         .from(form)
-        .where(eq(form.workflowId, workflowId)),
+        .where(and(eq(form.workflowId, workflowId), isNull(form.archivedAt))),
       db
         .select({
           serverId: workflowMcpTool.serverId,
@@ -746,7 +860,13 @@ export class WorkspaceVFS {
         })
         .from(workflowMcpTool)
         .innerJoin(workflowMcpServer, eq(workflowMcpTool.serverId, workflowMcpServer.id))
-        .where(eq(workflowMcpTool.workflowId, workflowId)),
+        .where(
+          and(
+            eq(workflowMcpTool.workflowId, workflowId),
+            isNull(workflowMcpTool.archivedAt),
+            isNull(workflowMcpServer.deletedAt)
+          )
+        ),
       db
         .select({
           id: a2aAgent.id,
@@ -757,7 +877,13 @@ export class WorkspaceVFS {
           capabilities: a2aAgent.capabilities,
         })
         .from(a2aAgent)
-        .where(and(eq(a2aAgent.workflowId, workflowId), eq(a2aAgent.workspaceId, workspaceId))),
+        .where(
+          and(
+            eq(a2aAgent.workflowId, workflowId),
+            eq(a2aAgent.workspaceId, workspaceId),
+            isNull(a2aAgent.archivedAt)
+          )
+        ),
       isDeployed
         ? db
             .select({
@@ -1109,6 +1235,103 @@ export class WorkspaceVFS {
     }
   }
 
+  private async materializeRecentlyDeleted(workspaceId: string, userId: string): Promise<void> {
+    try {
+      const [archivedWorkflows, archivedFolders, archivedTables, archivedFiles, archivedKBs] =
+        await Promise.all([
+          listWorkflows(workspaceId, { scope: 'archived' }),
+          db
+            .select({
+              id: workflowFolder.id,
+              name: workflowFolder.name,
+              archivedAt: workflowFolder.archivedAt,
+            })
+            .from(workflowFolder)
+            .where(
+              and(eq(workflowFolder.workspaceId, workspaceId), isNotNull(workflowFolder.archivedAt))
+            ),
+          listTables(workspaceId, { scope: 'archived' }),
+          listWorkspaceFiles(workspaceId, { scope: 'archived' }),
+          getKnowledgeBases(userId, workspaceId, 'archived'),
+        ])
+
+      for (const wf of archivedWorkflows) {
+        const safeName = sanitizeName(wf.name)
+        this.files.set(
+          `recently-deleted/workflows/${safeName}/meta.json`,
+          serializeWorkflowMeta(wf)
+        )
+      }
+
+      for (const folder of archivedFolders) {
+        const safeName = sanitizeName(folder.name)
+        this.files.set(
+          `recently-deleted/folders/${safeName}/meta.json`,
+          JSON.stringify(
+            { id: folder.id, name: folder.name, archivedAt: folder.archivedAt },
+            null,
+            2
+          )
+        )
+      }
+
+      for (const table of archivedTables) {
+        const safeName = sanitizeName(table.name)
+        this.files.set(
+          `recently-deleted/tables/${safeName}/meta.json`,
+          serializeTableMeta({
+            id: table.id,
+            name: table.name,
+            description: table.description,
+            schema: table.schema,
+            rowCount: table.rowCount,
+            maxRows: table.maxRows,
+            createdAt: table.createdAt,
+            updatedAt: table.updatedAt,
+          })
+        )
+      }
+
+      for (const file of archivedFiles) {
+        const safeName = sanitizeName(file.name)
+        this.files.set(
+          `recently-deleted/files/${safeName}/meta.json`,
+          serializeFileMeta({
+            id: file.id,
+            name: file.name,
+            contentType: file.type,
+            size: file.size,
+            uploadedAt: file.uploadedAt,
+          })
+        )
+      }
+
+      for (const kb of archivedKBs) {
+        const safeName = sanitizeName(kb.name)
+        this.files.set(
+          `recently-deleted/knowledgebases/${safeName}/meta.json`,
+          serializeKBMeta({
+            id: kb.id,
+            name: kb.name,
+            description: kb.description,
+            embeddingModel: kb.embeddingModel,
+            embeddingDimension: kb.embeddingDimension,
+            tokenCount: kb.tokenCount,
+            createdAt: kb.createdAt,
+            updatedAt: kb.updatedAt,
+            documentCount: kb.docCount,
+            connectorTypes: kb.connectorTypes,
+          })
+        )
+      }
+    } catch (err) {
+      logger.warn('Failed to materialize recently deleted resources', {
+        workspaceId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    }
+  }
+
   /**
    * Materialize environment data using shared service functions:
    * - getAccessibleEnvCredentials for workspace-scoped credentials
@@ -1120,7 +1343,10 @@ export class WorkspaceVFS {
   private async materializeEnvironment(
     workspaceId: string,
     userId: string
-  ): Promise<WorkspaceMdData['credentials']> {
+  ): Promise<{
+    oauthIntegrations: WorkspaceMdData['oauthIntegrations']
+    envVariables: WorkspaceMdData['envVariables']
+  }> {
     try {
       const [envCredentials, oauthCredentials, apiKeyRows, envData] = await Promise.all([
         getAccessibleEnvCredentials(workspaceId, userId),
@@ -1156,16 +1382,18 @@ export class WorkspaceVFS {
         serializeEnvironmentVariables(personalVarNames, workspaceVarNames)
       )
 
-      const envKeys = envCredentials.map((c) => c.envKey)
-      const oauthProviders = oauthCredentials.map((c) => c.providerId)
-      const allProviders = [...new Set([...oauthProviders, ...envKeys])]
-      return allProviders.map((key) => ({ providerId: key }))
+      const oauthProviders = [...new Set(oauthCredentials.map((c) => c.providerId))]
+      const envKeys = [...new Set(envCredentials.map((c) => c.envKey))]
+      return {
+        oauthIntegrations: oauthProviders.map((key) => ({ providerId: key })),
+        envVariables: envKeys,
+      }
     } catch (err) {
       logger.warn('Failed to materialize environment data', {
         workspaceId,
         error: err instanceof Error ? err.message : String(err),
       })
-      return []
+      return { oauthIntegrations: [], envVariables: [] }
     }
   }
 }
diff --git a/apps/sim/lib/copilot/workflow-read-hashes.ts b/apps/sim/lib/copilot/workflow-read-hashes.ts
deleted file mode 100644
index adca180dc84..00000000000
--- a/apps/sim/lib/copilot/workflow-read-hashes.ts
+++ /dev/null
@@ -1,115 +0,0 @@
-import crypto from 'crypto'
-import { db } from '@sim/db'
-import { copilotWorkflowReadHashes } from '@sim/db/schema'
-import { and, eq } from 'drizzle-orm'
-import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
-
-type WorkflowStateLike = {
-  blocks?: Record<string, unknown>
-  edges?: unknown[]
-  loops?: Record<string, unknown>
-  parallels?: Record<string, unknown>
-}
-
-export function canonicalizeForHash(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map(canonicalizeForHash)
-  }
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value as Record<string, unknown>)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([key, nested]) => [key, canonicalizeForHash(nested)])
-    )
-  }
-  return value
-}
-
-export function hashCanonicalJson(value: unknown): string {
-  const canonical = JSON.stringify(canonicalizeForHash(value))
-  return crypto.createHash('sha256').update(canonical).digest('hex')
-}
-
-export function computeWorkflowReadHashFromSanitizedState(sanitizedState: unknown): string {
-  return hashCanonicalJson(sanitizedState)
-}
-
-export function computeWorkflowReadHashFromWorkflowState(state: WorkflowStateLike): {
-  sanitizedState: ReturnType<typeof sanitizeForCopilot>
-  hash: string
-} {
-  const sanitizedState = sanitizeForCopilot({
-    blocks: state.blocks || {},
-    edges: state.edges || [],
-    loops: state.loops || {},
-    parallels: state.parallels || {},
-  } as Parameters<typeof sanitizeForCopilot>[0])
-
-  return {
-    sanitizedState,
-    hash: computeWorkflowReadHashFromSanitizedState(sanitizedState),
-  }
-}
-
-export async function getWorkflowReadHash(
-  chatId: string,
-  workflowId: string
-): Promise<string | null> {
-  const [row] = await db
-    .select({ hash: copilotWorkflowReadHashes.hash })
-    .from(copilotWorkflowReadHashes)
-    .where(
-      and(
-        eq(copilotWorkflowReadHashes.chatId, chatId),
-        eq(copilotWorkflowReadHashes.workflowId, workflowId)
-      )
-    )
-    .limit(1)
-
-  return row?.hash ?? null
-}
-
-export async function upsertWorkflowReadHash(
-  chatId: string,
-  workflowId: string,
-  hash: string
-): Promise<void> {
-  await db
-    .insert(copilotWorkflowReadHashes)
-    .values({
-      chatId,
-      workflowId,
-      hash,
-      updatedAt: new Date(),
-    })
-    .onConflictDoUpdate({
-      target: [copilotWorkflowReadHashes.chatId, copilotWorkflowReadHashes.workflowId],
-      set: {
-        hash,
-        updatedAt: new Date(),
-      },
-    })
-}
-
-export async function upsertWorkflowReadHashForWorkflowState(
-  chatId: string,
-  workflowId: string,
-  state: WorkflowStateLike
-): Promise<{
-  sanitizedState: ReturnType<typeof sanitizeForCopilot>
-  hash: string
-}> {
-  const computed = computeWorkflowReadHashFromWorkflowState(state)
-  await upsertWorkflowReadHash(chatId, workflowId, computed.hash)
-  return computed
-}
-
-export async function upsertWorkflowReadHashForSanitizedState(
-  chatId: string,
-  workflowId: string,
-  sanitizedState: unknown
-): Promise<string> {
-  const hash = computeWorkflowReadHashFromSanitizedState(sanitizedState)
-  await upsertWorkflowReadHash(chatId, workflowId, hash)
-  return hash
-}
diff --git a/apps/sim/lib/core/async-jobs/backends/bullmq.ts b/apps/sim/lib/core/async-jobs/backends/bullmq.ts
deleted file mode 100644
index f67aead4ce0..00000000000
--- a/apps/sim/lib/core/async-jobs/backends/bullmq.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job as BullMQJob } from 'bullmq'
-import {
-  type EnqueueOptions,
-  JOB_STATUS,
-  type Job,
-  type JobQueueBackend,
-  type JobStatus,
-  type JobType,
-} from '@/lib/core/async-jobs/types'
-import { type BullMQJobData, createBullMQJobData, getBullMQQueue } from '@/lib/core/bullmq'
-
-const logger = createLogger('BullMQJobQueue')
-
-function mapBullMQStatus(status: string): JobStatus {
-  switch (status) {
-    case 'active':
-      return JOB_STATUS.PROCESSING
-    case 'completed':
-      return JOB_STATUS.COMPLETED
-    case 'failed':
-      return JOB_STATUS.FAILED
-    default:
-      return JOB_STATUS.PENDING
-  }
-}
-
-async function toJob(
-  queueType: JobType,
-  bullJob: BullMQJob<BullMQJobData<unknown>> | null
-): Promise<Job | null> {
-  if (!bullJob) {
-    return null
-  }
-
-  const status = mapBullMQStatus(await bullJob.getState())
-
-  return {
-    id: bullJob.id ?? '',
-    type: queueType,
-    payload: bullJob.data.payload,
-    status,
-    createdAt: new Date(bullJob.timestamp),
-    startedAt: bullJob.processedOn ? new Date(bullJob.processedOn) : undefined,
-    completedAt: bullJob.finishedOn ? new Date(bullJob.finishedOn) : undefined,
-    attempts: bullJob.attemptsMade,
-    maxAttempts: bullJob.opts.attempts ?? 1,
-    error: bullJob.failedReason || undefined,
-    output: bullJob.returnvalue,
-    metadata: bullJob.data.metadata ?? {},
-  }
-}
-
-export class BullMQJobQueue implements JobQueueBackend {
-  async enqueue<TPayload>(
-    type: JobType,
-    payload: TPayload,
-    options?: EnqueueOptions
-  ): Promise<string> {
-    const queue = getBullMQQueue(type)
-
-    const job = await queue.add(
-      options?.name ?? type,
-      createBullMQJobData(payload, options?.metadata),
-      {
-        jobId: options?.jobId,
-        attempts: options?.maxAttempts,
-        priority: options?.priority,
-        delay: options?.delayMs,
-      }
-    )
-
-    logger.debug('Enqueued job via BullMQ', {
-      jobId: job.id,
-      type,
-      name: options?.name ?? type,
-    })
-
-    return String(job.id)
-  }
-
-  async getJob(jobId: string): Promise<Job | null> {
-    const workflowJob = await getBullMQQueue('workflow-execution').getJob(jobId)
-    if (workflowJob) {
-      return toJob('workflow-execution', workflowJob)
-    }
-
-    const webhookJob = await getBullMQQueue('webhook-execution').getJob(jobId)
-    if (webhookJob) {
-      return toJob('webhook-execution', webhookJob)
-    }
-
-    const scheduleJob = await getBullMQQueue('schedule-execution').getJob(jobId)
-    if (scheduleJob) {
-      return toJob('schedule-execution', scheduleJob)
-    }
-
-    const resumeJob = await getBullMQQueue('resume-execution').getJob(jobId)
-    if (resumeJob) {
-      return toJob('resume-execution', resumeJob)
-    }
-
-    return null
-  }
-
-  async startJob(_jobId: string): Promise<void> {}
-
-  async completeJob(_jobId: string, _output: unknown): Promise<void> {}
-
-  async markJobFailed(_jobId: string, _error: string): Promise<void> {}
-}
diff --git a/apps/sim/lib/core/async-jobs/backends/index.ts b/apps/sim/lib/core/async-jobs/backends/index.ts
index 0abb55d6af5..86c7a990f10 100644
--- a/apps/sim/lib/core/async-jobs/backends/index.ts
+++ b/apps/sim/lib/core/async-jobs/backends/index.ts
@@ -1,3 +1,2 @@
-export { BullMQJobQueue } from './bullmq'
 export { DatabaseJobQueue } from './database'
 export { TriggerDevJobQueue } from './trigger-dev'
diff --git a/apps/sim/lib/core/async-jobs/config.ts b/apps/sim/lib/core/async-jobs/config.ts
index c4f0a4dcf83..b28f5453ea4 100644
--- a/apps/sim/lib/core/async-jobs/config.ts
+++ b/apps/sim/lib/core/async-jobs/config.ts
@@ -1,6 +1,5 @@
 import { createLogger } from '@sim/logger'
 import type { AsyncBackendType, JobQueueBackend } from '@/lib/core/async-jobs/types'
-import { isBullMQEnabled } from '@/lib/core/bullmq'
 import { isTriggerDevEnabled } from '@/lib/core/config/feature-flags'
 
 const logger = createLogger('AsyncJobsConfig')
@@ -11,17 +10,13 @@ let cachedInlineBackend: JobQueueBackend | null = null
 
 /**
  * Determines which async backend to use based on environment configuration.
- * Follows the fallback chain: trigger.dev → bullmq → database
+ * Follows the fallback chain: trigger.dev → database
  */
 export function getAsyncBackendType(): AsyncBackendType {
   if (isTriggerDevEnabled) {
     return 'trigger-dev'
   }
 
-  if (isBullMQEnabled()) {
-    return 'bullmq'
-  }
-
   return 'database'
 }
 
@@ -42,11 +37,6 @@ export async function getJobQueue(): Promise<JobQueueBackend> {
       cachedBackend = new TriggerDevJobQueue()
       break
     }
-    case 'bullmq': {
-      const { BullMQJobQueue } = await import('@/lib/core/async-jobs/backends/bullmq')
-      cachedBackend = new BullMQJobQueue()
-      break
-    }
     case 'database': {
       const { DatabaseJobQueue } = await import('@/lib/core/async-jobs/backends/database')
       cachedBackend = new DatabaseJobQueue()
@@ -72,7 +62,7 @@ export function getCurrentBackendType(): AsyncBackendType | null {
 }
 
 /**
- * Gets a job queue backend that bypasses Trigger.dev (BullMQ -> Database).
+ * Gets a job queue backend that bypasses Trigger.dev (Database only).
  * Used for execution paths that must avoid Trigger.dev cold starts.
  */
 export async function getInlineJobQueue(): Promise<JobQueueBackend> {
@@ -80,18 +70,10 @@ export async function getInlineJobQueue(): Promise<JobQueueBackend> {
     return cachedInlineBackend
   }
 
-  let type: string
-  if (isBullMQEnabled()) {
-    const { BullMQJobQueue } = await import('@/lib/core/async-jobs/backends/bullmq')
-    cachedInlineBackend = new BullMQJobQueue()
-    type = 'bullmq'
-  } else {
-    const { DatabaseJobQueue } = await import('@/lib/core/async-jobs/backends/database')
-    cachedInlineBackend = new DatabaseJobQueue()
-    type = 'database'
-  }
+  const { DatabaseJobQueue } = await import('@/lib/core/async-jobs/backends/database')
+  cachedInlineBackend = new DatabaseJobQueue()
 
-  logger.info(`Inline job backend initialized: ${type}`)
+  logger.info('Inline job backend initialized: database')
   return cachedInlineBackend
 }
 
@@ -103,10 +85,6 @@ export function shouldExecuteInline(): boolean {
   return getAsyncBackendType() === 'database'
 }
 
-export function shouldUseBullMQ(): boolean {
-  return isBullMQEnabled()
-}
-
 /**
  * Resets the cached backend (useful for testing)
  */
diff --git a/apps/sim/lib/core/async-jobs/index.ts b/apps/sim/lib/core/async-jobs/index.ts
index 76ec7072207..24e6f1e526f 100644
--- a/apps/sim/lib/core/async-jobs/index.ts
+++ b/apps/sim/lib/core/async-jobs/index.ts
@@ -5,7 +5,6 @@ export {
   getJobQueue,
   resetJobQueueCache,
   shouldExecuteInline,
-  shouldUseBullMQ,
 } from './config'
 export type {
   AsyncBackendType,
diff --git a/apps/sim/lib/core/async-jobs/types.ts b/apps/sim/lib/core/async-jobs/types.ts
index 7b09bdb7b0d..7531a46eca7 100644
--- a/apps/sim/lib/core/async-jobs/types.ts
+++ b/apps/sim/lib/core/async-jobs/types.ts
@@ -105,4 +105,4 @@ export interface JobQueueBackend {
   markJobFailed(jobId: string, error: string): Promise<void>
 }
 
-export type AsyncBackendType = 'trigger-dev' | 'bullmq' | 'database'
+export type AsyncBackendType = 'trigger-dev' | 'database'
diff --git a/apps/sim/lib/core/bullmq/connection.ts b/apps/sim/lib/core/bullmq/connection.ts
deleted file mode 100644
index e888f5772a7..00000000000
--- a/apps/sim/lib/core/bullmq/connection.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import type { ConnectionOptions } from 'bullmq'
-import { env, isTruthy } from '@/lib/core/config/env'
-
-export function isBullMQEnabled(): boolean {
-  return isTruthy(env.CONCURRENCY_CONTROL_ENABLED) && Boolean(env.REDIS_URL)
-}
-
-export function getBullMQConnectionOptions(): ConnectionOptions {
-  if (!env.REDIS_URL) {
-    throw new Error('BullMQ requires REDIS_URL')
-  }
-
-  const redisUrl = new URL(env.REDIS_URL)
-  const isTls = redisUrl.protocol === 'rediss:'
-  const port = redisUrl.port ? Number.parseInt(redisUrl.port, 10) : 6379
-  const dbPath = redisUrl.pathname.replace('/', '')
-  const db = dbPath ? Number.parseInt(dbPath, 10) : undefined
-
-  return {
-    host: redisUrl.hostname,
-    port,
-    username: redisUrl.username || undefined,
-    password: redisUrl.password || undefined,
-    db: Number.isFinite(db) ? db : undefined,
-    maxRetriesPerRequest: null,
-    enableReadyCheck: false,
-    ...(isTls ? { tls: {} } : {}),
-  }
-}
diff --git a/apps/sim/lib/core/bullmq/index.ts b/apps/sim/lib/core/bullmq/index.ts
deleted file mode 100644
index efe937aa476..00000000000
--- a/apps/sim/lib/core/bullmq/index.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-export { getBullMQConnectionOptions, isBullMQEnabled } from './connection'
-export {
-  type BullMQJobData,
-  createBullMQJobData,
-  getBullMQQueue,
-  getBullMQQueueByName,
-  getKnowledgeConnectorSyncQueue,
-  getKnowledgeDocumentProcessingQueue,
-  getMothershipJobExecutionQueue,
-  getWorkflowQueueEvents,
-  getWorkspaceNotificationDeliveryQueue,
-  KNOWLEDGE_CONNECTOR_SYNC_QUEUE,
-  KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE,
-  MOTHERSHIP_JOB_EXECUTION_QUEUE,
-  WORKSPACE_NOTIFICATION_DELIVERY_QUEUE,
-} from './queues'
diff --git a/apps/sim/lib/core/bullmq/queues.ts b/apps/sim/lib/core/bullmq/queues.ts
deleted file mode 100644
index f90c2e90c85..00000000000
--- a/apps/sim/lib/core/bullmq/queues.ts
+++ /dev/null
@@ -1,209 +0,0 @@
-import { Queue, QueueEvents } from 'bullmq'
-import type { JobMetadata, JobType } from '@/lib/core/async-jobs/types'
-import { getBullMQConnectionOptions } from '@/lib/core/bullmq/connection'
-import type { WorkspaceDispatchQueueName } from '@/lib/core/workspace-dispatch/types'
-
-export const KNOWLEDGE_CONNECTOR_SYNC_QUEUE = 'knowledge-connector-sync' as const
-export const KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE = 'knowledge-process-document' as const
-export const MOTHERSHIP_JOB_EXECUTION_QUEUE = 'mothership-job-execution' as const
-export const WORKSPACE_NOTIFICATION_DELIVERY_QUEUE = 'workspace-notification-delivery' as const
-
-export interface BullMQJobData<TPayload> {
-  payload: TPayload
-  metadata?: JobMetadata
-}
-
-let workflowQueueInstance: Queue | null = null
-let webhookQueueInstance: Queue | null = null
-let scheduleQueueInstance: Queue | null = null
-let resumeQueueInstance: Queue | null = null
-let knowledgeConnectorSyncQueueInstance: Queue | null = null
-let knowledgeDocumentProcessingQueueInstance: Queue | null = null
-let mothershipJobExecutionQueueInstance: Queue | null = null
-let workspaceNotificationDeliveryQueueInstance: Queue | null = null
-let workflowQueueEventsInstance: QueueEvents | null = null
-
-function getQueueDefaultOptions(type: JobType) {
-  switch (type) {
-    case 'workflow-execution':
-      return {
-        attempts: 3,
-        backoff: { type: 'exponential' as const, delay: 1000 },
-        removeOnComplete: { age: 24 * 60 * 60 },
-        removeOnFail: { age: 7 * 24 * 60 * 60 },
-      }
-    case 'webhook-execution':
-      return {
-        attempts: 2,
-        backoff: { type: 'exponential' as const, delay: 2000 },
-        removeOnComplete: { age: 24 * 60 * 60 },
-        removeOnFail: { age: 3 * 24 * 60 * 60 },
-      }
-    case 'schedule-execution':
-      return {
-        attempts: 2,
-        backoff: { type: 'exponential' as const, delay: 5000 },
-        removeOnComplete: { age: 24 * 60 * 60 },
-        removeOnFail: { age: 3 * 24 * 60 * 60 },
-      }
-    case 'resume-execution':
-      return {
-        attempts: 1,
-        removeOnComplete: { age: 24 * 60 * 60 },
-        removeOnFail: { age: 3 * 24 * 60 * 60 },
-      }
-  }
-}
-
-function createQueue(type: JobType): Queue {
-  return new Queue(type, {
-    connection: getBullMQConnectionOptions(),
-    defaultJobOptions: getQueueDefaultOptions(type),
-  })
-}
-
-function createNamedQueue(
-  name:
-    | typeof KNOWLEDGE_CONNECTOR_SYNC_QUEUE
-    | typeof KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE
-    | typeof MOTHERSHIP_JOB_EXECUTION_QUEUE
-    | typeof WORKSPACE_NOTIFICATION_DELIVERY_QUEUE
-): Queue {
-  switch (name) {
-    case KNOWLEDGE_CONNECTOR_SYNC_QUEUE:
-      return new Queue(name, {
-        connection: getBullMQConnectionOptions(),
-        defaultJobOptions: {
-          attempts: 3,
-          backoff: { type: 'exponential', delay: 5000 },
-          removeOnComplete: { age: 24 * 60 * 60 },
-          removeOnFail: { age: 7 * 24 * 60 * 60 },
-        },
-      })
-    case KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE:
-      return new Queue(name, {
-        connection: getBullMQConnectionOptions(),
-        defaultJobOptions: {
-          attempts: 3,
-          backoff: { type: 'exponential', delay: 1000 },
-          removeOnComplete: { age: 24 * 60 * 60 },
-          removeOnFail: { age: 7 * 24 * 60 * 60 },
-        },
-      })
-    case MOTHERSHIP_JOB_EXECUTION_QUEUE:
-      return new Queue(name, {
-        connection: getBullMQConnectionOptions(),
-        defaultJobOptions: {
-          attempts: 1,
-          removeOnComplete: { age: 24 * 60 * 60 },
-          removeOnFail: { age: 7 * 24 * 60 * 60 },
-        },
-      })
-    case WORKSPACE_NOTIFICATION_DELIVERY_QUEUE:
-      return new Queue(name, {
-        connection: getBullMQConnectionOptions(),
-        defaultJobOptions: {
-          attempts: 1,
-          removeOnComplete: { age: 24 * 60 * 60 },
-          removeOnFail: { age: 7 * 24 * 60 * 60 },
-        },
-      })
-  }
-}
-
-export function getBullMQQueue(type: JobType): Queue {
-  switch (type) {
-    case 'workflow-execution':
-      if (!workflowQueueInstance) {
-        workflowQueueInstance = createQueue(type)
-      }
-      return workflowQueueInstance
-    case 'webhook-execution':
-      if (!webhookQueueInstance) {
-        webhookQueueInstance = createQueue(type)
-      }
-      return webhookQueueInstance
-    case 'schedule-execution':
-      if (!scheduleQueueInstance) {
-        scheduleQueueInstance = createQueue(type)
-      }
-      return scheduleQueueInstance
-    case 'resume-execution':
-      if (!resumeQueueInstance) {
-        resumeQueueInstance = createQueue(type)
-      }
-      return resumeQueueInstance
-  }
-}
-
-export function getBullMQQueueByName(queueName: WorkspaceDispatchQueueName): Queue {
-  switch (queueName) {
-    case 'workflow-execution':
-    case 'webhook-execution':
-    case 'schedule-execution':
-    case 'resume-execution':
-      return getBullMQQueue(queueName)
-    case KNOWLEDGE_CONNECTOR_SYNC_QUEUE:
-      return getKnowledgeConnectorSyncQueue()
-    case KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE:
-      return getKnowledgeDocumentProcessingQueue()
-    case MOTHERSHIP_JOB_EXECUTION_QUEUE:
-      return getMothershipJobExecutionQueue()
-    case WORKSPACE_NOTIFICATION_DELIVERY_QUEUE:
-      return getWorkspaceNotificationDeliveryQueue()
-  }
-}
-
-export function getWorkflowQueueEvents(): QueueEvents {
-  if (!workflowQueueEventsInstance) {
-    workflowQueueEventsInstance = new QueueEvents('workflow-execution', {
-      connection: getBullMQConnectionOptions(),
-    })
-  }
-
-  return workflowQueueEventsInstance
-}
-
-export function getKnowledgeConnectorSyncQueue(): Queue {
-  if (!knowledgeConnectorSyncQueueInstance) {
-    knowledgeConnectorSyncQueueInstance = createNamedQueue(KNOWLEDGE_CONNECTOR_SYNC_QUEUE)
-  }
-
-  return knowledgeConnectorSyncQueueInstance
-}
-
-export function getKnowledgeDocumentProcessingQueue(): Queue {
-  if (!knowledgeDocumentProcessingQueueInstance) {
-    knowledgeDocumentProcessingQueueInstance = createNamedQueue(KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE)
-  }
-
-  return knowledgeDocumentProcessingQueueInstance
-}
-
-export function getMothershipJobExecutionQueue(): Queue {
-  if (!mothershipJobExecutionQueueInstance) {
-    mothershipJobExecutionQueueInstance = createNamedQueue(MOTHERSHIP_JOB_EXECUTION_QUEUE)
-  }
-
-  return mothershipJobExecutionQueueInstance
-}
-
-export function getWorkspaceNotificationDeliveryQueue(): Queue {
-  if (!workspaceNotificationDeliveryQueueInstance) {
-    workspaceNotificationDeliveryQueueInstance = createNamedQueue(
-      WORKSPACE_NOTIFICATION_DELIVERY_QUEUE
-    )
-  }
-
-  return workspaceNotificationDeliveryQueueInstance
-}
-
-export function createBullMQJobData<TPayload>(
-  payload: TPayload,
-  metadata?: JobMetadata
-): BullMQJobData<TPayload> {
-  return {
-    payload,
-    metadata: metadata ?? {},
-  }
-}
diff --git a/apps/sim/lib/core/config/env.ts b/apps/sim/lib/core/config/env.ts
index 7b329a2fd12..46224446d9c 100644
--- a/apps/sim/lib/core/config/env.ts
+++ b/apps/sim/lib/core/config/env.ts
@@ -38,9 +38,6 @@ export const env = createEnv({
     AGENT_INDEXER_API_KEY:                 z.string().min(1).optional(),           // API key for agent indexer authentication
     COPILOT_STREAM_TTL_SECONDS:            z.number().optional(),                  // Redis TTL for copilot SSE buffer
     COPILOT_STREAM_EVENT_LIMIT:            z.number().optional(),                  // Max events retained per stream
-    COPILOT_STREAM_RESERVE_BATCH:          z.number().optional(),                  // Event ID reservation batch size
-    COPILOT_STREAM_FLUSH_INTERVAL_MS:      z.number().optional(),                  // Buffer flush interval in ms
-    COPILOT_STREAM_FLUSH_MAX_BATCH:        z.number().optional(),                  // Max events per flush batch
 
     // Database & Storage
     REDIS_URL:                             z.string().url().optional(),            // Redis connection string for caching/sessions
@@ -147,6 +144,12 @@ export const env = createEnv({
     // Admin API
     ADMIN_API_KEY:                         z.string().min(32).optional(),          // Admin API key for self-hosted GitOps access (generate with: openssl rand -hex 32)
 
+    // Mothership Admin
+    MOTHERSHIP_API_ADMIN_KEY:              z.string().min(1).optional(),           // Admin API key for mothership/copilot admin endpoints
+    MOTHERSHIP_DEV_URL:                    z.string().url().optional(),            // Mothership dev environment URL
+    MOTHERSHIP_STAGING_URL:                z.string().url().optional(),            // Mothership staging environment URL
+    MOTHERSHIP_PROD_URL:                   z.string().url().optional(),            // Mothership production environment URL
+
     // Infrastructure & Deployment
     NEXT_RUNTIME:                          z.string().optional(),                  // Next.js runtime environment
     DOCKER_BUILD:                          z.boolean().optional(),                 // Flag indicating Docker build environment
@@ -187,10 +190,7 @@ export const env = createEnv({
     FREE_PLAN_LOG_RETENTION_DAYS:          z.string().optional(),                  // Log retention days for free plan users
 
     // Admission & Burst Protection
-    CONCURRENCY_CONTROL_ENABLED:           z.string().optional().default('false'),  // Set to 'true' to enable BullMQ-based concurrency control (default: inline execution)
     ADMISSION_GATE_MAX_INFLIGHT:           z.string().optional().default('500'),   // Max concurrent in-flight execution requests per pod
-    DISPATCH_MAX_QUEUE_PER_WORKSPACE:      z.string().optional().default('1000'),  // Max queued dispatch jobs per workspace
-    DISPATCH_MAX_QUEUE_GLOBAL:             z.string().optional().default('50000'), // Max queued dispatch jobs globally
 
     // Rate Limiting Configuration
     RATE_LIMIT_WINDOW_MS:                  z.string().optional().default('60000'), // Rate limit window duration in milliseconds (default: 1 minute)
@@ -203,11 +203,6 @@ export const env = createEnv({
     RATE_LIMIT_TEAM_ASYNC:                 z.string().optional().default('2500'),  // Team tier async API executions per minute
     RATE_LIMIT_ENTERPRISE_SYNC:            z.string().optional().default('600'),   // Enterprise tier sync API executions per minute
     RATE_LIMIT_ENTERPRISE_ASYNC:           z.string().optional().default('5000'),  // Enterprise tier async API executions per minute
-    WORKSPACE_CONCURRENCY_FREE:            z.string().optional().default('5'),     // Free tier concurrent workspace executions
-    WORKSPACE_CONCURRENCY_PRO:             z.string().optional().default('50'),    // Pro tier concurrent workspace executions
-    WORKSPACE_CONCURRENCY_TEAM:            z.string().optional().default('200'),   // Team/Max tier concurrent workspace executions
-    WORKSPACE_CONCURRENCY_ENTERPRISE:      z.string().optional().default('200'),   // Enterprise default concurrent workspace executions
-
     // Timeout Configuration
     EXECUTION_TIMEOUT_FREE:                z.string().optional().default('300'),   // 5 minutes
     EXECUTION_TIMEOUT_PRO:                 z.string().optional().default('3000'),  // 50 minutes
@@ -328,6 +323,7 @@ export const env = createEnv({
     // E2B Remote Code Execution
     E2B_ENABLED:                           z.string().optional(),                  // Enable E2B remote code execution
     E2B_API_KEY:                           z.string().optional(),                  // E2B API key for sandbox creation
+    MOTHERSHIP_E2B_TEMPLATE_ID:             z.string().optional(),                  // Custom E2B template with pre-installed CLI tools for shell execution
 
     // Credential Sets (Email Polling) - for self-hosted deployments
     CREDENTIAL_SETS_ENABLED:               z.boolean().optional(),                 // Enable credential sets on self-hosted (bypasses plan requirements)
diff --git a/apps/sim/lib/core/workspace-dispatch/adapter.ts b/apps/sim/lib/core/workspace-dispatch/adapter.ts
deleted file mode 100644
index 6d55a70ff3c..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/adapter.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import type {
-  WorkspaceDispatchClaimResult,
-  WorkspaceDispatchEnqueueInput,
-  WorkspaceDispatchJobRecord,
-  WorkspaceDispatchLane,
-} from '@/lib/core/workspace-dispatch/types'
-
-export interface WorkspaceDispatchStorageAdapter {
-  saveDispatchJob(record: WorkspaceDispatchJobRecord): Promise<void>
-  getDispatchJobRecord(jobId: string): Promise<WorkspaceDispatchJobRecord | null>
-  listDispatchJobsByStatuses(
-    statuses: readonly WorkspaceDispatchJobRecord['status'][]
-  ): Promise<WorkspaceDispatchJobRecord[]>
-  updateDispatchJobRecord(
-    jobId: string,
-    updater: (record: WorkspaceDispatchJobRecord) => WorkspaceDispatchJobRecord
-  ): Promise<WorkspaceDispatchJobRecord | null>
-  enqueueWorkspaceDispatchJob(
-    input: WorkspaceDispatchEnqueueInput
-  ): Promise<WorkspaceDispatchJobRecord>
-  restoreWorkspaceDispatchJob(record: WorkspaceDispatchJobRecord): Promise<void>
-  claimWorkspaceJob(
-    workspaceId: string,
-    options: {
-      lanes: readonly WorkspaceDispatchLane[]
-      concurrencyLimit: number
-      leaseId: string
-      now: number
-      leaseTtlMs: number
-    }
-  ): Promise<WorkspaceDispatchClaimResult>
-  getWorkspaceQueueDepth(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<number>
-  getGlobalQueueDepth(): Promise<number>
-  reconcileGlobalQueueDepth(knownCount: number): Promise<void>
-  popNextWorkspaceId(): Promise<string | null>
-  getQueuedWorkspaceCount(): Promise<number>
-  hasActiveWorkspace(workspaceId: string): Promise<boolean>
-  ensureWorkspaceActive(workspaceId: string, readyAt?: number): Promise<void>
-  requeueWorkspaceId(workspaceId: string): Promise<void>
-  workspaceHasPendingJobs(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<boolean>
-  getNextWorkspaceJob(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<WorkspaceDispatchJobRecord | null>
-  removeWorkspaceJobFromLane(
-    workspaceId: string,
-    lane: WorkspaceDispatchLane,
-    jobId: string
-  ): Promise<void>
-  cleanupExpiredWorkspaceLeases(workspaceId: string): Promise<void>
-  countActiveWorkspaceLeases(workspaceId: string): Promise<number>
-  hasWorkspaceLease(workspaceId: string, leaseId: string): Promise<boolean>
-  createWorkspaceLease(workspaceId: string, leaseId: string, ttlMs: number): Promise<number>
-  refreshWorkspaceLease(workspaceId: string, leaseId: string, ttlMs: number): Promise<number>
-  releaseWorkspaceLease(workspaceId: string, leaseId: string): Promise<void>
-  removeWorkspaceIfIdle(workspaceId: string, lanes: readonly WorkspaceDispatchLane[]): Promise<void>
-  markDispatchJobAdmitted(
-    jobId: string,
-    workspaceId: string,
-    leaseId: string,
-    leaseExpiresAt: number
-  ): Promise<void>
-  markDispatchJobAdmitting(
-    jobId: string,
-    workspaceId: string,
-    leaseId: string,
-    leaseExpiresAt: number
-  ): Promise<void>
-  markDispatchJobRunning(jobId: string): Promise<void>
-  markDispatchJobCompleted(jobId: string, output: unknown): Promise<void>
-  markDispatchJobFailed(jobId: string, error: string): Promise<void>
-  clear(): Promise<void>
-  dispose(): void
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/dispatcher.test.ts b/apps/sim/lib/core/workspace-dispatch/dispatcher.test.ts
deleted file mode 100644
index 6daa485f918..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/dispatcher.test.ts
+++ /dev/null
@@ -1,175 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const { mockGetWorkspaceConcurrencyLimit, mockAcquireLock, mockReleaseLock } = vi.hoisted(() => ({
-  mockGetWorkspaceConcurrencyLimit: vi.fn(),
-  mockAcquireLock: vi.fn(),
-  mockReleaseLock: vi.fn(),
-}))
-
-vi.mock('@/lib/billing/workspace-concurrency', () => ({
-  getWorkspaceConcurrencyLimit: mockGetWorkspaceConcurrencyLimit,
-}))
-
-vi.mock('@/lib/core/config/redis', () => ({
-  acquireLock: mockAcquireLock,
-  releaseLock: mockReleaseLock,
-  getRedisClient: vi.fn().mockReturnValue(null),
-}))
-
-vi.mock('@/lib/core/bullmq', () => ({
-  getBullMQQueueByName: vi.fn().mockReturnValue({
-    add: vi.fn().mockResolvedValue({ id: 'bullmq-1' }),
-  }),
-}))
-
-import { MemoryWorkspaceDispatchStorage } from '@/lib/core/workspace-dispatch/memory-store'
-import {
-  DISPATCH_SCAN_RESULTS,
-  dispatchNextAdmissibleWorkspaceJob,
-} from '@/lib/core/workspace-dispatch/planner'
-import {
-  enqueueWorkspaceDispatchJob,
-  setWorkspaceDispatchStorageAdapter,
-} from '@/lib/core/workspace-dispatch/store'
-
-describe('workspace dispatch integration (memory-backed)', () => {
-  let store: MemoryWorkspaceDispatchStorage
-
-  beforeEach(async () => {
-    vi.clearAllMocks()
-    store = new MemoryWorkspaceDispatchStorage()
-    setWorkspaceDispatchStorageAdapter(store)
-
-    mockGetWorkspaceConcurrencyLimit.mockResolvedValue(5)
-    mockAcquireLock.mockResolvedValue(true)
-    mockReleaseLock.mockResolvedValue(true)
-  })
-
-  async function enqueue(
-    workspaceId: string,
-    overrides: { lane?: string; delayMs?: number; priority?: number } = {}
-  ) {
-    return enqueueWorkspaceDispatchJob({
-      workspaceId,
-      lane: (overrides.lane ?? 'runtime') as 'runtime',
-      queueName: 'workflow-execution',
-      bullmqJobName: 'workflow-execution',
-      bullmqPayload: { payload: { workflowId: 'wf-1' } },
-      metadata: { workflowId: 'wf-1' },
-      delayMs: overrides.delayMs,
-      priority: overrides.priority,
-    })
-  }
-
-  it('admits jobs round-robin across workspaces', async () => {
-    await enqueue('ws-a')
-    await enqueue('ws-b')
-    await enqueue('ws-a')
-
-    const r1 = await dispatchNextAdmissibleWorkspaceJob()
-    const r2 = await dispatchNextAdmissibleWorkspaceJob()
-    const r3 = await dispatchNextAdmissibleWorkspaceJob()
-
-    expect(r1).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-    expect(r2).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-    expect(r3).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-  })
-
-  it('respects workspace concurrency limits', async () => {
-    mockGetWorkspaceConcurrencyLimit.mockResolvedValue(1)
-
-    await enqueue('ws-a')
-    await enqueue('ws-a')
-
-    const r1 = await dispatchNextAdmissibleWorkspaceJob()
-    expect(r1).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-
-    const r2 = await dispatchNextAdmissibleWorkspaceJob()
-    expect(r2).toBe(DISPATCH_SCAN_RESULTS.NO_PROGRESS)
-  })
-
-  it('skips delayed jobs and admits ready ones in same lane', async () => {
-    await enqueue('ws-a', { delayMs: 60_000 })
-    await enqueue('ws-a', { delayMs: 0 })
-
-    const r1 = await dispatchNextAdmissibleWorkspaceJob()
-    expect(r1).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-  })
-
-  it('returns delayed when all jobs are delayed', async () => {
-    await enqueue('ws-a', { delayMs: 60_000 })
-
-    const r1 = await dispatchNextAdmissibleWorkspaceJob()
-    expect(r1).toBe(DISPATCH_SCAN_RESULTS.NO_PROGRESS)
-  })
-
-  it('returns no_workspace when queue is empty', async () => {
-    const result = await dispatchNextAdmissibleWorkspaceJob()
-    expect(result).toBe(DISPATCH_SCAN_RESULTS.NO_WORKSPACE)
-  })
-
-  it('lease cleanup frees capacity for new admissions', async () => {
-    mockGetWorkspaceConcurrencyLimit.mockResolvedValue(1)
-
-    const record = await enqueue('ws-a')
-    await enqueue('ws-a')
-
-    const r1 = await dispatchNextAdmissibleWorkspaceJob()
-    expect(r1).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-
-    const updated = await store.getDispatchJobRecord(record.id)
-    if (updated?.lease) {
-      await store.releaseWorkspaceLease('ws-a', updated.lease.leaseId)
-    }
-
-    const r2 = await dispatchNextAdmissibleWorkspaceJob()
-    expect(r2).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-  })
-
-  it('expired leases are cleaned up during claim', async () => {
-    mockGetWorkspaceConcurrencyLimit.mockResolvedValue(1)
-
-    await enqueue('ws-a')
-    await enqueue('ws-a')
-
-    const claimResult = await store.claimWorkspaceJob('ws-a', {
-      lanes: ['runtime'],
-      concurrencyLimit: 1,
-      leaseId: 'old-lease',
-      now: Date.now(),
-      leaseTtlMs: 1,
-    })
-    expect(claimResult.type).toBe('admitted')
-
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    const r2 = await dispatchNextAdmissibleWorkspaceJob()
-    expect(r2).toBe(DISPATCH_SCAN_RESULTS.ADMITTED)
-  })
-
-  it('recovers job to waiting via restoreWorkspaceDispatchJob', async () => {
-    const record = await enqueue('ws-a')
-
-    await store.claimWorkspaceJob('ws-a', {
-      lanes: ['runtime'],
-      concurrencyLimit: 1,
-      leaseId: 'lease-1',
-      now: Date.now(),
-      leaseTtlMs: 1000,
-    })
-
-    await store.markDispatchJobAdmitted(record.id, 'ws-a', 'lease-1', Date.now() + 10000)
-
-    const admitted = await store.getDispatchJobRecord(record.id)
-    expect(admitted).toBeDefined()
-    const resetRecord = { ...admitted!, status: 'waiting' as const, lease: undefined }
-    await store.restoreWorkspaceDispatchJob(resetRecord)
-
-    const restored = await store.getDispatchJobRecord(record.id)
-    expect(restored?.status).toBe('waiting')
-    expect(restored?.lease).toBeUndefined()
-  })
-})
diff --git a/apps/sim/lib/core/workspace-dispatch/dispatcher.ts b/apps/sim/lib/core/workspace-dispatch/dispatcher.ts
deleted file mode 100644
index 1122107ea4b..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/dispatcher.ts
+++ /dev/null
@@ -1,156 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { env } from '@/lib/core/config/env'
-import {
-  enqueueWorkspaceDispatchJob,
-  getDispatchJobRecord,
-  getGlobalQueueDepth,
-  getQueuedWorkspaceCount,
-  getWorkspaceQueueDepth,
-} from '@/lib/core/workspace-dispatch/store'
-import {
-  WORKSPACE_DISPATCH_LANES,
-  type WorkspaceDispatchEnqueueInput,
-  type WorkspaceDispatchJobRecord,
-} from '@/lib/core/workspace-dispatch/types'
-import { DISPATCH_SCAN_RESULTS, dispatchNextAdmissibleWorkspaceJob } from './planner'
-import { reconcileWorkspaceDispatchState } from './reconciler'
-
-const logger = createLogger('WorkspaceDispatcher')
-const WAIT_POLL_INTERVAL_MS = 250
-const RECONCILE_INTERVAL_MS = 30_000
-const MAX_QUEUE_PER_WORKSPACE = Number.parseInt(env.DISPATCH_MAX_QUEUE_PER_WORKSPACE ?? '') || 1000
-const MAX_QUEUE_GLOBAL = Number.parseInt(env.DISPATCH_MAX_QUEUE_GLOBAL ?? '') || 50_000
-
-let dispatcherRunning = false
-let dispatcherWakePending = false
-let lastReconcileAt = 0
-
-async function runDispatcherLoop(): Promise<void> {
-  if (dispatcherRunning) {
-    dispatcherWakePending = true
-    return
-  }
-
-  dispatcherRunning = true
-
-  try {
-    const now = Date.now()
-    if (now - lastReconcileAt >= RECONCILE_INTERVAL_MS) {
-      await reconcileWorkspaceDispatchState()
-      lastReconcileAt = now
-    }
-
-    do {
-      dispatcherWakePending = false
-      const queuedWorkspaces = await getQueuedWorkspaceCount()
-      if (queuedWorkspaces === 0) {
-        continue
-      }
-
-      let admitted = 0
-      let scanned = 0
-      const loopStartMs = Date.now()
-
-      for (let index = 0; index < queuedWorkspaces; index++) {
-        scanned++
-        const result = await dispatchNextAdmissibleWorkspaceJob()
-        if (result === DISPATCH_SCAN_RESULTS.ADMITTED) {
-          admitted++
-        }
-        if (result === DISPATCH_SCAN_RESULTS.NO_WORKSPACE) {
-          break
-        }
-      }
-
-      if (admitted > 0) {
-        dispatcherWakePending = true
-      }
-
-      if (admitted > 0 || scanned > 0) {
-        logger.info('Dispatcher pass', {
-          admitted,
-          scanned,
-          queuedWorkspaces,
-          durationMs: Date.now() - loopStartMs,
-        })
-      }
-    } while (dispatcherWakePending)
-  } catch (error) {
-    logger.error('Workspace dispatcher loop failed', { error })
-  } finally {
-    dispatcherRunning = false
-  }
-}
-
-export class DispatchQueueFullError extends Error {
-  readonly statusCode = 503
-
-  constructor(
-    readonly scope: 'workspace' | 'global',
-    readonly depth: number,
-    readonly limit: number
-  ) {
-    super(
-      scope === 'workspace'
-        ? `Workspace queue is at capacity (${depth}/${limit})`
-        : `Global dispatch queue is at capacity (${depth}/${limit})`
-    )
-    this.name = 'DispatchQueueFullError'
-  }
-}
-
-export async function enqueueWorkspaceDispatch(
-  input: WorkspaceDispatchEnqueueInput
-): Promise<string> {
-  const [workspaceDepth, globalDepth] = await Promise.all([
-    getWorkspaceQueueDepth(input.workspaceId, WORKSPACE_DISPATCH_LANES),
-    getGlobalQueueDepth(),
-  ])
-
-  if (workspaceDepth >= MAX_QUEUE_PER_WORKSPACE) {
-    logger.warn('Workspace dispatch queue at capacity', {
-      workspaceId: input.workspaceId,
-      depth: workspaceDepth,
-      limit: MAX_QUEUE_PER_WORKSPACE,
-    })
-    throw new DispatchQueueFullError('workspace', workspaceDepth, MAX_QUEUE_PER_WORKSPACE)
-  }
-
-  if (globalDepth >= MAX_QUEUE_GLOBAL) {
-    logger.warn('Global dispatch queue at capacity', {
-      depth: globalDepth,
-      limit: MAX_QUEUE_GLOBAL,
-    })
-    throw new DispatchQueueFullError('global', globalDepth, MAX_QUEUE_GLOBAL)
-  }
-
-  const record = await enqueueWorkspaceDispatchJob(input)
-  void runDispatcherLoop()
-  return record.id
-}
-
-export async function wakeWorkspaceDispatcher(): Promise<void> {
-  await runDispatcherLoop()
-}
-
-export async function waitForDispatchJob(
-  dispatchJobId: string,
-  timeoutMs: number
-): Promise<WorkspaceDispatchJobRecord> {
-  const deadline = Date.now() + timeoutMs
-
-  while (Date.now() < deadline) {
-    const record = await getDispatchJobRecord(dispatchJobId)
-    if (!record) {
-      throw new Error(`Dispatch job not found: ${dispatchJobId}`)
-    }
-
-    if (record.status === 'completed' || record.status === 'failed') {
-      return record
-    }
-
-    await new Promise((resolve) => setTimeout(resolve, WAIT_POLL_INTERVAL_MS))
-  }
-
-  throw new Error(`Timed out waiting for dispatch job ${dispatchJobId}`)
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/factory.ts b/apps/sim/lib/core/workspace-dispatch/factory.ts
deleted file mode 100644
index 3a07c68cf01..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/factory.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getRedisClient } from '@/lib/core/config/redis'
-import type { WorkspaceDispatchStorageAdapter } from '@/lib/core/workspace-dispatch/adapter'
-import { MemoryWorkspaceDispatchStorage } from '@/lib/core/workspace-dispatch/memory-store'
-import { RedisWorkspaceDispatchStorage } from '@/lib/core/workspace-dispatch/redis-store'
-
-const logger = createLogger('WorkspaceDispatchFactory')
-
-let cachedAdapter: WorkspaceDispatchStorageAdapter | null = null
-
-export function createWorkspaceDispatchStorageAdapter(): WorkspaceDispatchStorageAdapter {
-  if (cachedAdapter) {
-    return cachedAdapter
-  }
-
-  const redis = getRedisClient()
-
-  if (redis) {
-    logger.info('Workspace dispatcher: Using Redis storage')
-    const adapter = new RedisWorkspaceDispatchStorage(redis)
-    cachedAdapter = adapter
-    return adapter
-  }
-
-  logger.warn(
-    'Workspace dispatcher: Using in-memory storage; distributed fairness is disabled in multi-process deployments'
-  )
-  const adapter = new MemoryWorkspaceDispatchStorage()
-  cachedAdapter = adapter
-  return adapter
-}
-
-export function setWorkspaceDispatchStorageAdapter(adapter: WorkspaceDispatchStorageAdapter): void {
-  cachedAdapter = adapter
-}
-
-export function resetWorkspaceDispatchStorageAdapter(): void {
-  if (cachedAdapter) {
-    cachedAdapter.dispose()
-    cachedAdapter = null
-  }
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/index.ts b/apps/sim/lib/core/workspace-dispatch/index.ts
deleted file mode 100644
index 74645372c9f..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/index.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-export type { WorkspaceDispatchStorageAdapter } from './adapter'
-export {
-  DispatchQueueFullError,
-  enqueueWorkspaceDispatch,
-  waitForDispatchJob,
-  wakeWorkspaceDispatcher,
-} from './dispatcher'
-export {
-  createWorkspaceDispatchStorageAdapter,
-  resetWorkspaceDispatchStorageAdapter,
-} from './factory'
-export {
-  markDispatchJobAdmitted,
-  markDispatchJobAdmitting,
-  markDispatchJobCompleted,
-  markDispatchJobFailed,
-  markDispatchJobRunning,
-  refreshWorkspaceLease,
-  releaseWorkspaceLease,
-} from './store'
-export {
-  WORKSPACE_DISPATCH_LANES,
-  WORKSPACE_DISPATCH_STATUSES,
-  type WorkspaceDispatchEnqueueInput,
-  type WorkspaceDispatchJobContext,
-  type WorkspaceDispatchJobRecord,
-  type WorkspaceDispatchLane,
-  type WorkspaceDispatchLeaseInfo,
-  type WorkspaceDispatchQueueName,
-  type WorkspaceDispatchStatus,
-} from './types'
-export { getDispatchRuntimeMetadata, runDispatchedJob } from './worker'
diff --git a/apps/sim/lib/core/workspace-dispatch/memory-store.test.ts b/apps/sim/lib/core/workspace-dispatch/memory-store.test.ts
deleted file mode 100644
index 87a54de26d1..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/memory-store.test.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { afterEach, describe, expect, it } from 'vitest'
-import { MemoryWorkspaceDispatchStorage } from '@/lib/core/workspace-dispatch/memory-store'
-
-describe('memory workspace dispatch storage', () => {
-  const store = new MemoryWorkspaceDispatchStorage()
-
-  afterEach(async () => {
-    await store.clear()
-  })
-
-  it('claims a runnable job and marks it admitting with a lease', async () => {
-    const record = await store.enqueueWorkspaceDispatchJob({
-      workspaceId: 'workspace-1',
-      lane: 'runtime',
-      queueName: 'workflow-execution',
-      bullmqJobName: 'workflow-execution',
-      bullmqPayload: { payload: { workflowId: 'workflow-1' } },
-      metadata: {
-        workflowId: 'workflow-1',
-      },
-    })
-
-    const result = await store.claimWorkspaceJob('workspace-1', {
-      lanes: ['runtime'],
-      concurrencyLimit: 1,
-      leaseId: 'lease-1',
-      now: Date.now(),
-      leaseTtlMs: 1000,
-    })
-
-    expect(result.type).toBe('admitted')
-    if (result.type === 'admitted') {
-      expect(result.record.id).toBe(record.id)
-      expect(result.record.status).toBe('admitting')
-      expect(result.record.lease?.leaseId).toBe('lease-1')
-    }
-  })
-
-  it('returns delayed when only delayed jobs exist', async () => {
-    await store.enqueueWorkspaceDispatchJob({
-      workspaceId: 'workspace-1',
-      lane: 'runtime',
-      queueName: 'workflow-execution',
-      bullmqJobName: 'workflow-execution',
-      bullmqPayload: { payload: { workflowId: 'workflow-1' } },
-      metadata: {
-        workflowId: 'workflow-1',
-      },
-      delayMs: 5000,
-    })
-
-    const result = await store.claimWorkspaceJob('workspace-1', {
-      lanes: ['runtime'],
-      concurrencyLimit: 1,
-      leaseId: 'lease-2',
-      now: Date.now(),
-      leaseTtlMs: 1000,
-    })
-
-    expect(result.type).toBe('delayed')
-  })
-})
diff --git a/apps/sim/lib/core/workspace-dispatch/memory-store.ts b/apps/sim/lib/core/workspace-dispatch/memory-store.ts
deleted file mode 100644
index 52295172bb3..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/memory-store.ts
+++ /dev/null
@@ -1,506 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { generateId } from '@/lib/core/utils/uuid'
-import type { WorkspaceDispatchStorageAdapter } from '@/lib/core/workspace-dispatch/adapter'
-import {
-  WORKSPACE_DISPATCH_CLAIM_RESULTS,
-  type WorkspaceDispatchClaimResult,
-  type WorkspaceDispatchEnqueueInput,
-  type WorkspaceDispatchJobRecord,
-  type WorkspaceDispatchLane,
-} from '@/lib/core/workspace-dispatch/types'
-
-const logger = createLogger('WorkspaceDispatchMemoryStore')
-const JOB_TTL_MS = 48 * 60 * 60 * 1000
-
-export class MemoryWorkspaceDispatchStorage implements WorkspaceDispatchStorageAdapter {
-  private jobs = new Map<string, WorkspaceDispatchJobRecord>()
-  private workspaceOrder: string[] = []
-  private laneQueues = new Map<string, string[]>()
-  private leases = new Map<string, Map<string, number>>()
-  private cleanupInterval: NodeJS.Timeout | null = null
-
-  constructor() {
-    this.cleanupInterval = setInterval(() => {
-      void this.clearExpiredState()
-    }, 60_000)
-    this.cleanupInterval.unref()
-  }
-
-  private queueKey(workspaceId: string, lane: WorkspaceDispatchLane): string {
-    return `${workspaceId}:${lane}`
-  }
-
-  private ensureWorkspaceQueued(workspaceId: string): void {
-    if (!this.workspaceOrder.includes(workspaceId)) {
-      this.workspaceOrder.push(workspaceId)
-    }
-  }
-
-  private getLaneQueue(workspaceId: string, lane: WorkspaceDispatchLane): string[] {
-    const key = this.queueKey(workspaceId, lane)
-    const existing = this.laneQueues.get(key)
-    if (existing) {
-      return existing
-    }
-
-    const queue: string[] = []
-    this.laneQueues.set(key, queue)
-    return queue
-  }
-
-  private sortQueue(queue: string[]): void {
-    queue.sort((leftId, rightId) => {
-      const left = this.jobs.get(leftId)
-      const right = this.jobs.get(rightId)
-      if (!left || !right) {
-        return 0
-      }
-
-      if (left.priority !== right.priority) {
-        return left.priority - right.priority
-      }
-
-      return left.createdAt - right.createdAt
-    })
-  }
-
-  private getLeaseMap(workspaceId: string): Map<string, number> {
-    const existing = this.leases.get(workspaceId)
-    if (existing) {
-      return existing
-    }
-
-    const leaseMap = new Map<string, number>()
-    this.leases.set(workspaceId, leaseMap)
-    return leaseMap
-  }
-
-  private async clearExpiredState(): Promise<void> {
-    const now = Date.now()
-
-    for (const [jobId, record] of this.jobs.entries()) {
-      if (
-        (record.status === 'completed' || record.status === 'failed') &&
-        record.completedAt &&
-        now - record.completedAt > JOB_TTL_MS
-      ) {
-        this.jobs.delete(jobId)
-      }
-    }
-
-    for (const [workspaceId, leaseMap] of this.leases.entries()) {
-      for (const [leaseId, expiresAt] of leaseMap.entries()) {
-        if (expiresAt <= now) {
-          leaseMap.delete(leaseId)
-        }
-      }
-      if (leaseMap.size === 0) {
-        this.leases.delete(workspaceId)
-      }
-    }
-  }
-
-  async saveDispatchJob(record: WorkspaceDispatchJobRecord): Promise<void> {
-    this.jobs.set(record.id, record)
-  }
-
-  async getDispatchJobRecord(jobId: string): Promise<WorkspaceDispatchJobRecord | null> {
-    return this.jobs.get(jobId) ?? null
-  }
-
-  async listDispatchJobsByStatuses(
-    statuses: readonly WorkspaceDispatchJobRecord['status'][]
-  ): Promise<WorkspaceDispatchJobRecord[]> {
-    return Array.from(this.jobs.values()).filter((record) => statuses.includes(record.status))
-  }
-
-  private static readonly TERMINAL_STATUSES = new Set(['completed', 'failed'])
-
-  async updateDispatchJobRecord(
-    jobId: string,
-    updater: (record: WorkspaceDispatchJobRecord) => WorkspaceDispatchJobRecord
-  ): Promise<WorkspaceDispatchJobRecord | null> {
-    const current = this.jobs.get(jobId)
-    if (!current) {
-      return null
-    }
-
-    const updated = updater(current)
-    if (
-      MemoryWorkspaceDispatchStorage.TERMINAL_STATUSES.has(current.status) &&
-      !MemoryWorkspaceDispatchStorage.TERMINAL_STATUSES.has(updated.status)
-    ) {
-      return current
-    }
-
-    this.jobs.set(jobId, updated)
-    return updated
-  }
-
-  async enqueueWorkspaceDispatchJob(
-    input: WorkspaceDispatchEnqueueInput
-  ): Promise<WorkspaceDispatchJobRecord> {
-    const id = input.id ?? `dispatch_${generateId().replace(/-/g, '').slice(0, 20)}`
-    const createdAt = Date.now()
-
-    const record: WorkspaceDispatchJobRecord = {
-      id,
-      workspaceId: input.workspaceId,
-      lane: input.lane,
-      queueName: input.queueName,
-      bullmqJobName: input.bullmqJobName,
-      bullmqPayload: input.bullmqPayload,
-      metadata: input.metadata,
-      priority: input.priority ?? 100,
-      maxAttempts: input.maxAttempts,
-      delayMs: input.delayMs,
-      status: 'waiting',
-      createdAt,
-    }
-
-    this.jobs.set(id, record)
-    const queue = this.getLaneQueue(record.workspaceId, record.lane)
-    queue.push(id)
-    this.sortQueue(queue)
-    this.ensureWorkspaceQueued(record.workspaceId)
-    return record
-  }
-
-  async restoreWorkspaceDispatchJob(record: WorkspaceDispatchJobRecord): Promise<void> {
-    this.jobs.set(record.id, record)
-    const queue = this.getLaneQueue(record.workspaceId, record.lane)
-    if (!queue.includes(record.id)) {
-      queue.push(record.id)
-      this.sortQueue(queue)
-    }
-    this.ensureWorkspaceQueued(record.workspaceId)
-  }
-
-  async claimWorkspaceJob(
-    workspaceId: string,
-    options: {
-      lanes: readonly WorkspaceDispatchLane[]
-      concurrencyLimit: number
-      leaseId: string
-      now: number
-      leaseTtlMs: number
-    }
-  ): Promise<WorkspaceDispatchClaimResult> {
-    await this.cleanupExpiredWorkspaceLeases(workspaceId)
-    if (this.getLeaseMap(workspaceId).size >= options.concurrencyLimit) {
-      this.ensureWorkspaceQueued(workspaceId)
-      return { type: WORKSPACE_DISPATCH_CLAIM_RESULTS.LIMIT_REACHED }
-    }
-
-    let selectedRecord: WorkspaceDispatchJobRecord | null = null
-    let selectedLane: WorkspaceDispatchLane | null = null
-    let nextReadyAt: number | null = null
-
-    for (const lane of options.lanes) {
-      const queue = this.getLaneQueue(workspaceId, lane)
-      for (let scanIndex = 0; scanIndex < queue.length && scanIndex < 20; ) {
-        const jobId = queue[scanIndex]
-        const record = this.jobs.get(jobId)
-        if (!record) {
-          queue.splice(scanIndex, 1)
-          continue
-        }
-
-        const readyAt = record.createdAt + (record.delayMs ?? 0)
-        if (readyAt <= options.now) {
-          selectedRecord = record
-          selectedLane = lane
-          queue.splice(scanIndex, 1)
-          break
-        }
-
-        nextReadyAt = nextReadyAt ? Math.min(nextReadyAt, readyAt) : readyAt
-        scanIndex++
-      }
-
-      if (selectedRecord) {
-        break
-      }
-    }
-
-    if (!selectedRecord || !selectedLane) {
-      const hasPending = await this.workspaceHasPendingJobs(workspaceId, options.lanes)
-      if (!hasPending) {
-        this.workspaceOrder = this.workspaceOrder.filter((value) => value !== workspaceId)
-        return { type: WORKSPACE_DISPATCH_CLAIM_RESULTS.EMPTY }
-      }
-
-      this.ensureWorkspaceQueued(workspaceId)
-      return {
-        type: WORKSPACE_DISPATCH_CLAIM_RESULTS.DELAYED,
-        nextReadyAt: nextReadyAt ?? options.now,
-      }
-    }
-
-    const leaseExpiresAt = options.now + options.leaseTtlMs
-    this.getLeaseMap(workspaceId).set(options.leaseId, leaseExpiresAt)
-
-    const updatedRecord: WorkspaceDispatchJobRecord = {
-      ...selectedRecord,
-      status: 'admitting',
-      lease: {
-        workspaceId,
-        leaseId: options.leaseId,
-      },
-      metadata: {
-        ...selectedRecord.metadata,
-        dispatchLeaseExpiresAt: leaseExpiresAt,
-      },
-    }
-    this.jobs.set(updatedRecord.id, updatedRecord)
-
-    const hasPending = await this.workspaceHasPendingJobs(workspaceId, options.lanes)
-    if (hasPending) {
-      this.ensureWorkspaceQueued(workspaceId)
-    } else {
-      this.workspaceOrder = this.workspaceOrder.filter((value) => value !== workspaceId)
-    }
-
-    return {
-      type: WORKSPACE_DISPATCH_CLAIM_RESULTS.ADMITTED,
-      record: updatedRecord,
-      leaseId: options.leaseId,
-      leaseExpiresAt,
-    }
-  }
-
-  async getWorkspaceQueueDepth(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<number> {
-    let depth = 0
-    for (const lane of lanes) {
-      depth += this.getLaneQueue(workspaceId, lane).length
-    }
-    return depth
-  }
-
-  async getGlobalQueueDepth(): Promise<number> {
-    const terminalStatuses = new Set(['completed', 'failed'])
-    let count = 0
-    for (const job of this.jobs.values()) {
-      if (!terminalStatuses.has(job.status)) {
-        count++
-      }
-    }
-    return count
-  }
-
-  async reconcileGlobalQueueDepth(_knownCount: number): Promise<void> {
-    // no-op: memory store computes depth on the fly
-  }
-
-  async popNextWorkspaceId(): Promise<string | null> {
-    const now = Date.now()
-    const maxScans = this.workspaceOrder.length
-    for (let i = 0; i < maxScans; i++) {
-      const id = this.workspaceOrder.shift()
-      if (!id) return null
-      const readyAt = this.workspaceReadyAt.get(id)
-      if (readyAt && readyAt > now) {
-        this.workspaceOrder.push(id)
-        continue
-      }
-      this.workspaceReadyAt.delete(id)
-      return id
-    }
-    return null
-  }
-
-  async getQueuedWorkspaceCount(): Promise<number> {
-    return this.workspaceOrder.length
-  }
-
-  async hasActiveWorkspace(workspaceId: string): Promise<boolean> {
-    return this.workspaceOrder.includes(workspaceId)
-  }
-
-  private workspaceReadyAt = new Map<string, number>()
-
-  async ensureWorkspaceActive(workspaceId: string, readyAt?: number): Promise<void> {
-    if (readyAt && readyAt > Date.now()) {
-      this.workspaceReadyAt.set(workspaceId, readyAt)
-    }
-    this.ensureWorkspaceQueued(workspaceId)
-  }
-
-  async requeueWorkspaceId(workspaceId: string): Promise<void> {
-    this.ensureWorkspaceQueued(workspaceId)
-  }
-
-  async workspaceHasPendingJobs(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<boolean> {
-    return lanes.some((lane) => this.getLaneQueue(workspaceId, lane).length > 0)
-  }
-
-  async getNextWorkspaceJob(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<WorkspaceDispatchJobRecord | null> {
-    for (const lane of lanes) {
-      const queue = this.getLaneQueue(workspaceId, lane)
-      while (queue.length > 0) {
-        const jobId = queue[0]
-        const job = this.jobs.get(jobId)
-        if (job) {
-          return job
-        }
-        queue.shift()
-      }
-    }
-
-    return null
-  }
-
-  async removeWorkspaceJobFromLane(
-    workspaceId: string,
-    lane: WorkspaceDispatchLane,
-    jobId: string
-  ): Promise<void> {
-    const queue = this.getLaneQueue(workspaceId, lane)
-    const index = queue.indexOf(jobId)
-    if (index >= 0) {
-      queue.splice(index, 1)
-    }
-  }
-
-  async cleanupExpiredWorkspaceLeases(workspaceId: string): Promise<void> {
-    const leaseMap = this.getLeaseMap(workspaceId)
-    const now = Date.now()
-    for (const [leaseId, expiresAt] of leaseMap.entries()) {
-      if (expiresAt <= now) {
-        leaseMap.delete(leaseId)
-      }
-    }
-  }
-
-  async countActiveWorkspaceLeases(workspaceId: string): Promise<number> {
-    await this.cleanupExpiredWorkspaceLeases(workspaceId)
-    return this.getLeaseMap(workspaceId).size
-  }
-
-  async hasWorkspaceLease(workspaceId: string, leaseId: string): Promise<boolean> {
-    await this.cleanupExpiredWorkspaceLeases(workspaceId)
-    return this.getLeaseMap(workspaceId).has(leaseId)
-  }
-
-  async createWorkspaceLease(workspaceId: string, leaseId: string, ttlMs: number): Promise<number> {
-    const expiresAt = Date.now() + ttlMs
-    this.getLeaseMap(workspaceId).set(leaseId, expiresAt)
-    return expiresAt
-  }
-
-  async refreshWorkspaceLease(
-    workspaceId: string,
-    leaseId: string,
-    ttlMs: number
-  ): Promise<number> {
-    return this.createWorkspaceLease(workspaceId, leaseId, ttlMs)
-  }
-
-  async releaseWorkspaceLease(workspaceId: string, leaseId: string): Promise<void> {
-    this.getLeaseMap(workspaceId).delete(leaseId)
-  }
-
-  async removeWorkspaceIfIdle(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<void> {
-    const hasPending = await this.workspaceHasPendingJobs(workspaceId, lanes)
-    if (!hasPending) {
-      this.workspaceOrder = this.workspaceOrder.filter((value) => value !== workspaceId)
-    }
-  }
-
-  async markDispatchJobAdmitted(
-    jobId: string,
-    workspaceId: string,
-    leaseId: string,
-    leaseExpiresAt: number
-  ): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'admitted',
-      admittedAt: Date.now(),
-      lease: {
-        workspaceId,
-        leaseId,
-      },
-      metadata: {
-        ...record.metadata,
-        dispatchLeaseExpiresAt: leaseExpiresAt,
-      },
-    }))
-  }
-
-  async markDispatchJobAdmitting(
-    jobId: string,
-    workspaceId: string,
-    leaseId: string,
-    leaseExpiresAt: number
-  ): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'admitting',
-      lease: {
-        workspaceId,
-        leaseId,
-      },
-      metadata: {
-        ...record.metadata,
-        dispatchLeaseExpiresAt: leaseExpiresAt,
-      },
-    }))
-  }
-
-  async markDispatchJobRunning(jobId: string): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'running',
-      startedAt: record.startedAt ?? Date.now(),
-    }))
-  }
-
-  async markDispatchJobCompleted(jobId: string, output: unknown): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'completed',
-      completedAt: Date.now(),
-      output,
-    }))
-  }
-
-  async markDispatchJobFailed(jobId: string, error: string): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'failed',
-      completedAt: Date.now(),
-      error,
-    }))
-  }
-
-  async clear(): Promise<void> {
-    this.jobs.clear()
-    this.workspaceOrder = []
-    this.laneQueues.clear()
-    this.leases.clear()
-    this.workspaceReadyAt.clear()
-  }
-
-  dispose(): void {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval)
-      this.cleanupInterval = null
-    }
-    void this.clear().catch((error) => {
-      logger.error('Failed to clear memory workspace dispatch storage', { error })
-    })
-  }
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/planner.ts b/apps/sim/lib/core/workspace-dispatch/planner.ts
deleted file mode 100644
index 9912b22aba2..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/planner.ts
+++ /dev/null
@@ -1,155 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getWorkspaceConcurrencyLimit } from '@/lib/billing/workspace-concurrency'
-import { type BullMQJobData, getBullMQQueueByName } from '@/lib/core/bullmq'
-import { acquireLock, releaseLock } from '@/lib/core/config/redis'
-import { generateId } from '@/lib/core/utils/uuid'
-import {
-  claimWorkspaceJob,
-  markDispatchJobAdmitted,
-  popNextWorkspaceId,
-  releaseWorkspaceLease,
-  removeWorkspaceIfIdle,
-  requeueWorkspaceId,
-} from '@/lib/core/workspace-dispatch/store'
-import {
-  WORKSPACE_DISPATCH_CLAIM_RESULTS,
-  WORKSPACE_DISPATCH_LANES,
-  type WorkspaceDispatchJobRecord,
-} from '@/lib/core/workspace-dispatch/types'
-
-const logger = createLogger('WorkspaceDispatchPlanner')
-
-const LEASE_TTL_MS = 15 * 60 * 1000
-const WORKSPACE_CLAIM_LOCK_TTL_SECONDS = 10
-
-export const DISPATCH_SCAN_RESULTS = {
-  NO_WORKSPACE: 'no_workspace',
-  NO_PROGRESS: 'no_progress',
-  ADMITTED: 'admitted',
-} as const
-
-export type DispatchScanResult = (typeof DISPATCH_SCAN_RESULTS)[keyof typeof DISPATCH_SCAN_RESULTS]
-
-function attachDispatchMetadata(
-  bullmqPayload: unknown,
-  record: WorkspaceDispatchJobRecord,
-  leaseId: string,
-  leaseExpiresAt: number
-): BullMQJobData<unknown> {
-  if (
-    bullmqPayload &&
-    typeof bullmqPayload === 'object' &&
-    'payload' in bullmqPayload &&
-    'metadata' in bullmqPayload
-  ) {
-    const data = bullmqPayload as BullMQJobData<unknown>
-    return {
-      payload: data.payload,
-      metadata: {
-        ...(data.metadata ?? {}),
-        dispatchJobId: record.id,
-        dispatchWorkspaceId: record.workspaceId,
-        dispatchLeaseId: leaseId,
-        dispatchLeaseExpiresAt: leaseExpiresAt,
-      },
-    }
-  }
-
-  return {
-    payload: bullmqPayload,
-    metadata: {
-      ...record.metadata,
-      dispatchJobId: record.id,
-      dispatchWorkspaceId: record.workspaceId,
-      dispatchLeaseId: leaseId,
-      dispatchLeaseExpiresAt: leaseExpiresAt,
-    },
-  }
-}
-
-async function finalizeAdmittedJob(
-  record: WorkspaceDispatchJobRecord,
-  leaseId: string,
-  leaseExpiresAt: number
-): Promise<void> {
-  try {
-    await getBullMQQueueByName(record.queueName).add(
-      record.bullmqJobName,
-      attachDispatchMetadata(record.bullmqPayload, record, leaseId, leaseExpiresAt),
-      {
-        jobId: record.id,
-        attempts: record.maxAttempts,
-        priority: record.priority,
-      }
-    )
-
-    await markDispatchJobAdmitted(record.id, record.workspaceId, leaseId, leaseExpiresAt)
-  } catch (error) {
-    await releaseWorkspaceLease(record.workspaceId, leaseId).catch(() => undefined)
-    throw error
-  }
-}
-
-export async function dispatchNextAdmissibleWorkspaceJob(): Promise<DispatchScanResult> {
-  const workspaceId = await popNextWorkspaceId()
-  if (!workspaceId) {
-    return DISPATCH_SCAN_RESULTS.NO_WORKSPACE
-  }
-
-  const lockValue = `lock_${generateId()}`
-  try {
-    const lockKey = `workspace-dispatch:claim-lock:${workspaceId}`
-    const acquired = await acquireLock(lockKey, lockValue, WORKSPACE_CLAIM_LOCK_TTL_SECONDS)
-    if (!acquired) {
-      await requeueWorkspaceId(workspaceId)
-      return DISPATCH_SCAN_RESULTS.NO_PROGRESS
-    }
-
-    const limit = await getWorkspaceConcurrencyLimit(workspaceId)
-    const leaseId = `lease_${generateId()}`
-    const claimResult = await claimWorkspaceJob(workspaceId, {
-      lanes: WORKSPACE_DISPATCH_LANES,
-      concurrencyLimit: limit,
-      leaseId,
-      now: Date.now(),
-      leaseTtlMs: LEASE_TTL_MS,
-    })
-
-    switch (claimResult.type) {
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.LIMIT_REACHED:
-        logger.debug('Workspace concurrency limit reached', { workspaceId, limit })
-        await requeueWorkspaceId(workspaceId)
-        return DISPATCH_SCAN_RESULTS.NO_PROGRESS
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.DELAYED:
-        logger.debug('Workspace has only delayed jobs', {
-          workspaceId,
-          nextReadyAt: claimResult.nextReadyAt,
-        })
-        return DISPATCH_SCAN_RESULTS.NO_PROGRESS
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.EMPTY:
-        await removeWorkspaceIfIdle(workspaceId, WORKSPACE_DISPATCH_LANES)
-        return DISPATCH_SCAN_RESULTS.NO_PROGRESS
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.ADMITTED:
-        logger.info('Admitting workspace job', {
-          workspaceId,
-          dispatchJobId: claimResult.record.id,
-          lane: claimResult.record.lane,
-          queueName: claimResult.record.queueName,
-        })
-        await finalizeAdmittedJob(
-          claimResult.record,
-          claimResult.leaseId,
-          claimResult.leaseExpiresAt
-        )
-        return DISPATCH_SCAN_RESULTS.ADMITTED
-    }
-  } catch (error) {
-    logger.error('Failed to dispatch workspace job', { workspaceId, error })
-    await requeueWorkspaceId(workspaceId)
-    return DISPATCH_SCAN_RESULTS.NO_PROGRESS
-  } finally {
-    await releaseLock(`workspace-dispatch:claim-lock:${workspaceId}`, lockValue).catch(
-      () => undefined
-    )
-  }
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/reconciler.test.ts b/apps/sim/lib/core/workspace-dispatch/reconciler.test.ts
deleted file mode 100644
index a61d0dc4d1b..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/reconciler.test.ts
+++ /dev/null
@@ -1,225 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const {
-  mockGetBullMQQueueByName,
-  mockHasActiveWorkspace,
-  mockEnsureWorkspaceActive,
-  mockHasWorkspaceLease,
-  mockListDispatchJobsByStatuses,
-  mockMarkDispatchJobAdmitted,
-  mockMarkDispatchJobCompleted,
-  mockMarkDispatchJobFailed,
-  mockRefreshWorkspaceLease,
-  mockReleaseWorkspaceLease,
-  mockRemoveWorkspaceJobFromLane,
-  mockRestoreWorkspaceDispatchJob,
-  mockWakeWorkspaceDispatcher,
-} = vi.hoisted(() => ({
-  mockGetBullMQQueueByName: vi.fn(),
-  mockHasActiveWorkspace: vi.fn(),
-  mockEnsureWorkspaceActive: vi.fn(),
-  mockHasWorkspaceLease: vi.fn(),
-  mockListDispatchJobsByStatuses: vi.fn(),
-  mockMarkDispatchJobAdmitted: vi.fn(),
-  mockMarkDispatchJobCompleted: vi.fn(),
-  mockMarkDispatchJobFailed: vi.fn(),
-  mockRefreshWorkspaceLease: vi.fn(),
-  mockReleaseWorkspaceLease: vi.fn(),
-  mockRemoveWorkspaceJobFromLane: vi.fn(),
-  mockRestoreWorkspaceDispatchJob: vi.fn(),
-  mockWakeWorkspaceDispatcher: vi.fn(),
-}))
-
-vi.mock('@sim/logger', () => ({
-  createLogger: () => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-  }),
-}))
-
-vi.mock('@/lib/core/bullmq', () => ({
-  getBullMQQueueByName: mockGetBullMQQueueByName,
-}))
-
-vi.mock('@/lib/core/workspace-dispatch/store', () => ({
-  ensureWorkspaceActive: mockEnsureWorkspaceActive,
-  hasActiveWorkspace: mockHasActiveWorkspace,
-  hasWorkspaceLease: mockHasWorkspaceLease,
-  listDispatchJobsByStatuses: mockListDispatchJobsByStatuses,
-  markDispatchJobAdmitted: mockMarkDispatchJobAdmitted,
-  markDispatchJobCompleted: mockMarkDispatchJobCompleted,
-  markDispatchJobFailed: mockMarkDispatchJobFailed,
-  reconcileGlobalQueueDepth: vi.fn().mockResolvedValue(undefined),
-  refreshWorkspaceLease: mockRefreshWorkspaceLease,
-  releaseWorkspaceLease: mockReleaseWorkspaceLease,
-  removeWorkspaceJobFromLane: mockRemoveWorkspaceJobFromLane,
-  restoreWorkspaceDispatchJob: mockRestoreWorkspaceDispatchJob,
-}))
-
-vi.mock('@/lib/core/workspace-dispatch/dispatcher', () => ({
-  wakeWorkspaceDispatcher: mockWakeWorkspaceDispatcher,
-}))
-
-import { reconcileWorkspaceDispatchState } from '@/lib/core/workspace-dispatch/reconciler'
-
-describe('workspace dispatch reconciler', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockHasActiveWorkspace.mockResolvedValue(true)
-    mockRemoveWorkspaceJobFromLane.mockResolvedValue(undefined)
-  })
-
-  it('marks dispatch job completed when BullMQ job is completed', async () => {
-    mockListDispatchJobsByStatuses.mockResolvedValue([
-      {
-        id: 'dispatch-1',
-        workspaceId: 'workspace-1',
-        lane: 'runtime',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'workflow-execution',
-        bullmqPayload: {},
-        metadata: {},
-        priority: 10,
-        status: 'running',
-        createdAt: 1,
-        lease: {
-          workspaceId: 'workspace-1',
-          leaseId: 'lease-1',
-        },
-      },
-    ])
-    mockGetBullMQQueueByName.mockReturnValue({
-      getJob: vi.fn().mockResolvedValue({
-        getState: vi.fn().mockResolvedValue('completed'),
-        returnvalue: { ok: true },
-      }),
-    })
-
-    await reconcileWorkspaceDispatchState()
-
-    expect(mockMarkDispatchJobCompleted).toHaveBeenCalledWith('dispatch-1', { ok: true })
-    expect(mockReleaseWorkspaceLease).toHaveBeenCalledWith('workspace-1', 'lease-1')
-    expect(mockWakeWorkspaceDispatcher).toHaveBeenCalled()
-  })
-
-  it('restores admitted jobs to waiting when lease and BullMQ job are gone', async () => {
-    mockListDispatchJobsByStatuses.mockResolvedValue([
-      {
-        id: 'dispatch-2',
-        workspaceId: 'workspace-2',
-        lane: 'runtime',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'workflow-execution',
-        bullmqPayload: {},
-        metadata: {},
-        priority: 10,
-        status: 'admitted',
-        createdAt: 1,
-        admittedAt: 2,
-        lease: {
-          workspaceId: 'workspace-2',
-          leaseId: 'lease-2',
-        },
-      },
-    ])
-    mockGetBullMQQueueByName.mockReturnValue({
-      getJob: vi.fn().mockResolvedValue(null),
-    })
-    mockHasWorkspaceLease.mockResolvedValue(false)
-
-    await reconcileWorkspaceDispatchState()
-
-    expect(mockRestoreWorkspaceDispatchJob).toHaveBeenCalledWith(
-      expect.objectContaining({
-        id: 'dispatch-2',
-        status: 'waiting',
-        lease: undefined,
-      })
-    )
-    expect(mockWakeWorkspaceDispatcher).toHaveBeenCalled()
-  })
-
-  it('reacquires the lease for a live admitting BullMQ job', async () => {
-    mockListDispatchJobsByStatuses.mockResolvedValue([
-      {
-        id: 'dispatch-3',
-        workspaceId: 'workspace-3',
-        lane: 'runtime',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'workflow-execution',
-        bullmqPayload: {},
-        metadata: {
-          dispatchLeaseExpiresAt: 12345,
-        },
-        priority: 10,
-        status: 'admitting',
-        createdAt: 1,
-        lease: {
-          workspaceId: 'workspace-3',
-          leaseId: 'lease-3',
-        },
-      },
-    ])
-    mockGetBullMQQueueByName.mockReturnValue({
-      getJob: vi.fn().mockResolvedValue({
-        getState: vi.fn().mockResolvedValue('active'),
-      }),
-    })
-    mockHasWorkspaceLease.mockResolvedValue(false)
-
-    await reconcileWorkspaceDispatchState()
-
-    expect(mockRefreshWorkspaceLease).toHaveBeenCalledWith('workspace-3', 'lease-3', 15 * 60 * 1000)
-    expect(mockMarkDispatchJobAdmitted).toHaveBeenCalledWith(
-      'dispatch-3',
-      'workspace-3',
-      'lease-3',
-      12345
-    )
-    expect(mockRemoveWorkspaceJobFromLane).toHaveBeenCalledWith(
-      'workspace-3',
-      'runtime',
-      'dispatch-3'
-    )
-  })
-
-  it('releases leaked lease and restores waiting when BullMQ job is gone but lease remains', async () => {
-    mockListDispatchJobsByStatuses.mockResolvedValue([
-      {
-        id: 'dispatch-4',
-        workspaceId: 'workspace-4',
-        lane: 'runtime',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'workflow-execution',
-        bullmqPayload: {},
-        metadata: {},
-        priority: 10,
-        status: 'running',
-        createdAt: 1,
-        lease: {
-          workspaceId: 'workspace-4',
-          leaseId: 'lease-4',
-        },
-      },
-    ])
-    mockGetBullMQQueueByName.mockReturnValue({
-      getJob: vi.fn().mockResolvedValue(null),
-    })
-    mockHasWorkspaceLease.mockResolvedValue(true)
-
-    await reconcileWorkspaceDispatchState()
-
-    expect(mockReleaseWorkspaceLease).toHaveBeenCalledWith('workspace-4', 'lease-4')
-    expect(mockRestoreWorkspaceDispatchJob).toHaveBeenCalledWith(
-      expect.objectContaining({
-        id: 'dispatch-4',
-        status: 'waiting',
-      })
-    )
-  })
-})
diff --git a/apps/sim/lib/core/workspace-dispatch/reconciler.ts b/apps/sim/lib/core/workspace-dispatch/reconciler.ts
deleted file mode 100644
index 739d75533b1..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/reconciler.ts
+++ /dev/null
@@ -1,226 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { getBullMQQueueByName } from '@/lib/core/bullmq'
-import {
-  ensureWorkspaceActive,
-  hasActiveWorkspace,
-  hasWorkspaceLease,
-  listDispatchJobsByStatuses,
-  markDispatchJobAdmitted,
-  markDispatchJobCompleted,
-  markDispatchJobFailed,
-  markDispatchJobRunning,
-  reconcileGlobalQueueDepth,
-  refreshWorkspaceLease,
-  releaseWorkspaceLease,
-  removeWorkspaceJobFromLane,
-  restoreWorkspaceDispatchJob,
-} from '@/lib/core/workspace-dispatch/store'
-import type { WorkspaceDispatchJobRecord } from '@/lib/core/workspace-dispatch/types'
-import { wakeWorkspaceDispatcher } from './dispatcher'
-
-const logger = createLogger('WorkspaceDispatchReconciler')
-const LEASE_TTL_MS = 15 * 60 * 1000
-
-function resetToWaiting(record: WorkspaceDispatchJobRecord): WorkspaceDispatchJobRecord {
-  return {
-    ...record,
-    status: 'waiting',
-    admittedAt: undefined,
-    startedAt: undefined,
-    completedAt: undefined,
-    output: undefined,
-    error: undefined,
-    lease: undefined,
-  }
-}
-
-async function reconcileTerminalBullMQState(record: WorkspaceDispatchJobRecord): Promise<boolean> {
-  const queue = getBullMQQueueByName(record.queueName)
-  const job = await queue.getJob(record.id)
-  if (!job) {
-    return false
-  }
-
-  const state = await job.getState()
-  if (state === 'completed') {
-    await markDispatchJobCompleted(record.id, job.returnvalue)
-    if (record.lease) {
-      await releaseWorkspaceLease(record.lease.workspaceId, record.lease.leaseId)
-    }
-    return true
-  }
-
-  if (state === 'failed' && job.attemptsMade >= (job.opts.attempts ?? 1)) {
-    await markDispatchJobFailed(record.id, job.failedReason || 'Job failed')
-    if (record.lease) {
-      await releaseWorkspaceLease(record.lease.workspaceId, record.lease.leaseId)
-    }
-    return true
-  }
-
-  return false
-}
-
-async function reconcileStrandedDispatchJob(record: WorkspaceDispatchJobRecord): Promise<boolean> {
-  if (!record.lease && record.status !== 'waiting') {
-    await restoreWorkspaceDispatchJob(resetToWaiting(record))
-    return true
-  }
-
-  if (!record.lease) {
-    return false
-  }
-
-  const hasLease = await hasWorkspaceLease(record.lease.workspaceId, record.lease.leaseId)
-  const queue = getBullMQQueueByName(record.queueName)
-  const job = await queue.getJob(record.id)
-  if (hasLease) {
-    if (!job) {
-      await releaseWorkspaceLease(record.lease.workspaceId, record.lease.leaseId)
-      await restoreWorkspaceDispatchJob(resetToWaiting(record))
-      return true
-    }
-
-    return false
-  }
-
-  if (job) {
-    if (record.status === 'admitting') {
-      await refreshWorkspaceLease(record.lease.workspaceId, record.lease.leaseId, LEASE_TTL_MS)
-      await markDispatchJobAdmitted(
-        record.id,
-        record.lease.workspaceId,
-        record.lease.leaseId,
-        (record.metadata as { dispatchLeaseExpiresAt?: number }).dispatchLeaseExpiresAt ??
-          Date.now()
-      )
-      await removeWorkspaceJobFromLane(record.workspaceId, record.lane, record.id).catch(
-        () => undefined
-      )
-      return true
-    }
-    await refreshWorkspaceLease(record.lease.workspaceId, record.lease.leaseId, LEASE_TTL_MS)
-    if (record.status === 'admitted') {
-      await markDispatchJobRunning(record.id)
-      return true
-    }
-    return false
-  }
-
-  await restoreWorkspaceDispatchJob(resetToWaiting(record))
-  return true
-}
-
-async function reconcileTerminalDispatchLease(
-  record: WorkspaceDispatchJobRecord
-): Promise<boolean> {
-  if ((record.status !== 'completed' && record.status !== 'failed') || !record.lease) {
-    return false
-  }
-
-  const hasLease = await hasWorkspaceLease(record.lease.workspaceId, record.lease.leaseId)
-  if (!hasLease) {
-    return false
-  }
-
-  await releaseWorkspaceLease(record.lease.workspaceId, record.lease.leaseId)
-  return true
-}
-
-async function reconcileWaitingWorkspaceTracking(
-  waitingJobs: WorkspaceDispatchJobRecord[]
-): Promise<boolean> {
-  let changed = false
-  const earliestByWorkspace = new Map<string, number>()
-
-  for (const record of waitingJobs) {
-    const readyAt = record.createdAt + (record.delayMs ?? 0)
-    const current = earliestByWorkspace.get(record.workspaceId)
-    if (current === undefined || readyAt < current) {
-      earliestByWorkspace.set(record.workspaceId, readyAt)
-    }
-  }
-
-  for (const [workspaceId, nextReadyAt] of earliestByWorkspace.entries()) {
-    const active = await hasActiveWorkspace(workspaceId)
-    if (!active) {
-      await ensureWorkspaceActive(workspaceId, nextReadyAt)
-      changed = true
-    }
-  }
-
-  return changed
-}
-
-export async function reconcileWorkspaceDispatchState(): Promise<void> {
-  const allJobs = await listDispatchJobsByStatuses([
-    'waiting',
-    'admitting',
-    'admitted',
-    'running',
-    'completed',
-    'failed',
-  ])
-
-  const activeJobs: WorkspaceDispatchJobRecord[] = []
-  const waitingJobs: WorkspaceDispatchJobRecord[] = []
-  const terminalJobs: WorkspaceDispatchJobRecord[] = []
-  let nonTerminalCount = 0
-
-  for (const job of allJobs) {
-    switch (job.status) {
-      case 'admitting':
-      case 'admitted':
-      case 'running':
-        activeJobs.push(job)
-        nonTerminalCount++
-        break
-      case 'waiting':
-        waitingJobs.push(job)
-        nonTerminalCount++
-        break
-      case 'completed':
-      case 'failed':
-        terminalJobs.push(job)
-        break
-    }
-  }
-
-  let changed = false
-
-  for (const record of activeJobs) {
-    const terminal = await reconcileTerminalBullMQState(record)
-    if (terminal) {
-      changed = true
-      continue
-    }
-
-    const restored = await reconcileStrandedDispatchJob(record)
-    if (restored) {
-      changed = true
-    }
-  }
-
-  if (await reconcileWaitingWorkspaceTracking(waitingJobs)) {
-    changed = true
-  }
-
-  for (const record of terminalJobs) {
-    if (await reconcileTerminalDispatchLease(record)) {
-      changed = true
-    }
-  }
-
-  await reconcileGlobalQueueDepth(nonTerminalCount).catch((error) => {
-    logger.error('Failed to reconcile global queue depth', { error })
-  })
-
-  if (changed) {
-    logger.info('Workspace dispatch reconciliation updated state', {
-      activeJobsInspected: activeJobs.length,
-      waitingJobsInspected: waitingJobs.length,
-      terminalJobsInspected: terminalJobs.length,
-    })
-    await wakeWorkspaceDispatcher()
-  }
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/redis-store.ts b/apps/sim/lib/core/workspace-dispatch/redis-store.ts
deleted file mode 100644
index e7ce5a87696..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/redis-store.ts
+++ /dev/null
@@ -1,578 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type Redis from 'ioredis'
-import { generateId } from '@/lib/core/utils/uuid'
-import type { WorkspaceDispatchStorageAdapter } from '@/lib/core/workspace-dispatch/adapter'
-import {
-  WORKSPACE_DISPATCH_CLAIM_RESULTS,
-  type WorkspaceDispatchClaimResult,
-  type WorkspaceDispatchEnqueueInput,
-  type WorkspaceDispatchJobRecord,
-  type WorkspaceDispatchLane,
-} from '@/lib/core/workspace-dispatch/types'
-
-const logger = createLogger('WorkspaceDispatchRedisStore')
-
-const DISPATCH_PREFIX = 'workspace-dispatch:v1'
-const JOB_TTL_SECONDS = 48 * 60 * 60
-const SEQUENCE_KEY = `${DISPATCH_PREFIX}:sequence`
-const ACTIVE_WORKSPACES_KEY = `${DISPATCH_PREFIX}:workspaces`
-const GLOBAL_DEPTH_KEY = `${DISPATCH_PREFIX}:global-depth`
-const CLAIM_JOB_SCRIPT = `
-local workspaceId = ARGV[1]
-local now = tonumber(ARGV[2])
-local concurrencyLimit = tonumber(ARGV[3])
-local leaseId = ARGV[4]
-local leaseExpiresAt = tonumber(ARGV[5])
-local lanes = cjson.decode(ARGV[6])
-local sequenceKey = ARGV[7]
-local activeWorkspacesKey = ARGV[8]
-local jobPrefix = ARGV[9]
-local workspacePrefix = ARGV[10]
-local jobTtlSeconds = tonumber(ARGV[11])
-
-local function laneKey(lane)
-  return workspacePrefix .. workspaceId .. ':lane:' .. lane
-end
-
-local function leaseKey()
-  return workspacePrefix .. workspaceId .. ':leases'
-end
-
-local function workspaceHasPending()
-  local minReadyAt = nil
-  local hasPending = false
-
-  for _, lane in ipairs(lanes) do
-    local ids = redis.call('ZRANGE', laneKey(lane), 0, 0)
-    if #ids > 0 then
-      local raw = redis.call('GET', jobPrefix .. ids[1])
-      if raw then
-        hasPending = true
-        local record = cjson.decode(raw)
-        local readyAt = (record.createdAt or 0) + (record.delayMs or 0)
-        if (minReadyAt == nil) or (readyAt < minReadyAt) then
-          minReadyAt = readyAt
-        end
-      else
-        redis.call('ZREM', laneKey(lane), ids[1])
-      end
-    end
-  end
-
-  return hasPending, minReadyAt
-end
-
-redis.call('ZREMRANGEBYSCORE', leaseKey(), 0, now)
-local activeLeaseCount = redis.call('ZCARD', leaseKey())
-if activeLeaseCount >= concurrencyLimit then
-  return cjson.encode({ type = 'limit_reached' })
-end
-
-local selectedId = nil
-local selectedLane = nil
-local selectedRecord = nil
-local delayedNextReadyAt = nil
-
-local maxScanPerLane = 20
-
-for _, lane in ipairs(lanes) do
-  local ids = redis.call('ZRANGE', laneKey(lane), 0, maxScanPerLane - 1)
-  for _, candidateId in ipairs(ids) do
-    local raw = redis.call('GET', jobPrefix .. candidateId)
-    if raw then
-      local record = cjson.decode(raw)
-      local readyAt = (record.createdAt or 0) + (record.delayMs or 0)
-      if readyAt <= now then
-        selectedId = candidateId
-        selectedLane = lane
-        selectedRecord = record
-        break
-      end
-
-      if (delayedNextReadyAt == nil) or (readyAt < delayedNextReadyAt) then
-        delayedNextReadyAt = readyAt
-      end
-    else
-      redis.call('ZREM', laneKey(lane), candidateId)
-    end
-  end
-
-  if selectedRecord then
-    break
-  end
-end
-
-if selectedRecord == nil then
-  local hasPending, minReadyAt = workspaceHasPending()
-  if not hasPending then
-    return cjson.encode({ type = 'empty' })
-  end
-
-  local sequence = redis.call('INCR', sequenceKey)
-  local score = sequence
-  if minReadyAt ~= nil and minReadyAt > now then
-    score = minReadyAt * 1000000 + sequence
-  end
-  redis.call('ZADD', activeWorkspacesKey, score, workspaceId)
-
-  return cjson.encode({
-    type = 'delayed',
-    nextReadyAt = delayedNextReadyAt or minReadyAt or now
-  })
-end
-
-redis.call('ZADD', leaseKey(), leaseExpiresAt, leaseId)
-selectedRecord.status = 'admitting'
-selectedRecord.lease = {
-  workspaceId = workspaceId,
-  leaseId = leaseId
-}
-if selectedRecord.metadata == nil then
-  selectedRecord.metadata = {}
-end
-selectedRecord.metadata.dispatchLeaseExpiresAt = leaseExpiresAt
-
-redis.call('SET', jobPrefix .. selectedId, cjson.encode(selectedRecord), 'EX', jobTtlSeconds)
-redis.call('ZREM', laneKey(selectedLane), selectedId)
-
-local hasPending, minReadyAt = workspaceHasPending()
-if hasPending then
-  local sequence = redis.call('INCR', sequenceKey)
-  local score = sequence
-  if minReadyAt ~= nil and minReadyAt > now then
-    score = minReadyAt * 1000000 + sequence
-  end
-  redis.call('ZADD', activeWorkspacesKey, score, workspaceId)
-end
-
-return cjson.encode({
-  type = 'admitted',
-  record = selectedRecord,
-  leaseId = leaseId,
-  leaseExpiresAt = leaseExpiresAt
-})
-`
-
-function jobKey(jobId: string): string {
-  return `${DISPATCH_PREFIX}:job:${jobId}`
-}
-
-function workspaceLaneKey(workspaceId: string, lane: WorkspaceDispatchLane): string {
-  return `${DISPATCH_PREFIX}:workspace:${workspaceId}:lane:${lane}`
-}
-
-function workspaceLeaseKey(workspaceId: string): string {
-  return `${DISPATCH_PREFIX}:workspace:${workspaceId}:leases`
-}
-
-function createPriorityScore(priority: number, sequence: number): number {
-  return priority * 1_000_000_000_000 + sequence
-}
-
-export class RedisWorkspaceDispatchStorage implements WorkspaceDispatchStorageAdapter {
-  constructor(private redis: Redis) {}
-
-  private async nextSequence(): Promise<number> {
-    return this.redis.incr(SEQUENCE_KEY)
-  }
-
-  async saveDispatchJob(record: WorkspaceDispatchJobRecord): Promise<void> {
-    await this.redis.set(jobKey(record.id), JSON.stringify(record), 'EX', JOB_TTL_SECONDS)
-  }
-
-  async getDispatchJobRecord(jobId: string): Promise<WorkspaceDispatchJobRecord | null> {
-    const raw = await this.redis.get(jobKey(jobId))
-    if (!raw) {
-      return null
-    }
-
-    try {
-      return JSON.parse(raw) as WorkspaceDispatchJobRecord
-    } catch (error) {
-      logger.warn('Corrupted dispatch job record, deleting', { jobId, error })
-      await this.redis.del(jobKey(jobId))
-      return null
-    }
-  }
-
-  async listDispatchJobsByStatuses(
-    statuses: readonly WorkspaceDispatchJobRecord['status'][]
-  ): Promise<WorkspaceDispatchJobRecord[]> {
-    let cursor = '0'
-    const jobs: WorkspaceDispatchJobRecord[] = []
-
-    do {
-      const [nextCursor, keys] = await this.redis.scan(
-        cursor,
-        'MATCH',
-        `${DISPATCH_PREFIX}:job:*`,
-        'COUNT',
-        100
-      )
-      cursor = nextCursor
-
-      if (keys.length === 0) {
-        continue
-      }
-
-      const values = await this.redis.mget(...keys)
-      for (const value of values) {
-        if (!value) {
-          continue
-        }
-        try {
-          const record = JSON.parse(value) as WorkspaceDispatchJobRecord
-          if (statuses.includes(record.status)) {
-            jobs.push(record)
-          }
-        } catch {
-          // Best effort during reconciliation scans.
-        }
-      }
-    } while (cursor !== '0')
-
-    return jobs
-  }
-
-  private static readonly TERMINAL_STATUSES = new Set(['completed', 'failed'])
-
-  async updateDispatchJobRecord(
-    jobId: string,
-    updater: (record: WorkspaceDispatchJobRecord) => WorkspaceDispatchJobRecord
-  ): Promise<WorkspaceDispatchJobRecord | null> {
-    const current = await this.getDispatchJobRecord(jobId)
-    if (!current) {
-      return null
-    }
-
-    const updated = updater(current)
-    if (
-      RedisWorkspaceDispatchStorage.TERMINAL_STATUSES.has(current.status) &&
-      !RedisWorkspaceDispatchStorage.TERMINAL_STATUSES.has(updated.status)
-    ) {
-      return current
-    }
-
-    await this.saveDispatchJob(updated)
-    return updated
-  }
-
-  async enqueueWorkspaceDispatchJob(
-    input: WorkspaceDispatchEnqueueInput
-  ): Promise<WorkspaceDispatchJobRecord> {
-    const id = input.id ?? `dispatch_${generateId().replace(/-/g, '').slice(0, 20)}`
-    const createdAt = Date.now()
-    const sequence = await this.nextSequence()
-
-    const record: WorkspaceDispatchJobRecord = {
-      id,
-      workspaceId: input.workspaceId,
-      lane: input.lane,
-      queueName: input.queueName,
-      bullmqJobName: input.bullmqJobName,
-      bullmqPayload: input.bullmqPayload,
-      metadata: input.metadata,
-      priority: input.priority ?? 100,
-      maxAttempts: input.maxAttempts,
-      delayMs: input.delayMs,
-      status: 'waiting',
-      createdAt,
-    }
-
-    const score = createPriorityScore(record.priority, sequence)
-    const pipeline = this.redis.pipeline()
-    pipeline.set(jobKey(id), JSON.stringify(record), 'EX', JOB_TTL_SECONDS)
-    pipeline.zadd(workspaceLaneKey(record.workspaceId, record.lane), score, id)
-    pipeline.zadd(ACTIVE_WORKSPACES_KEY, 'NX', sequence, record.workspaceId)
-    pipeline.incr(GLOBAL_DEPTH_KEY)
-    await pipeline.exec()
-
-    return record
-  }
-
-  async restoreWorkspaceDispatchJob(record: WorkspaceDispatchJobRecord): Promise<void> {
-    const sequence = await this.nextSequence()
-    const score = createPriorityScore(record.priority, sequence)
-    const pipeline = this.redis.pipeline()
-    pipeline.set(jobKey(record.id), JSON.stringify(record), 'EX', JOB_TTL_SECONDS)
-    pipeline.zadd(workspaceLaneKey(record.workspaceId, record.lane), score, record.id)
-    pipeline.zadd(ACTIVE_WORKSPACES_KEY, 'NX', sequence, record.workspaceId)
-    await pipeline.exec()
-  }
-
-  async claimWorkspaceJob(
-    workspaceId: string,
-    options: {
-      lanes: readonly WorkspaceDispatchLane[]
-      concurrencyLimit: number
-      leaseId: string
-      now: number
-      leaseTtlMs: number
-    }
-  ): Promise<WorkspaceDispatchClaimResult> {
-    const raw = await this.redis.eval(
-      CLAIM_JOB_SCRIPT,
-      0,
-      workspaceId,
-      String(options.now),
-      String(options.concurrencyLimit),
-      options.leaseId,
-      String(options.now + options.leaseTtlMs),
-      JSON.stringify(options.lanes),
-      SEQUENCE_KEY,
-      ACTIVE_WORKSPACES_KEY,
-      `${DISPATCH_PREFIX}:job:`,
-      `${DISPATCH_PREFIX}:workspace:`,
-      String(JOB_TTL_SECONDS)
-    )
-
-    const parsed = JSON.parse(String(raw)) as WorkspaceDispatchClaimResult
-    switch (parsed.type) {
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.ADMITTED:
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.DELAYED:
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.LIMIT_REACHED:
-      case WORKSPACE_DISPATCH_CLAIM_RESULTS.EMPTY:
-        return parsed
-      default:
-        throw new Error(
-          `Unknown dispatch claim result: ${String((parsed as { type?: string }).type)}`
-        )
-    }
-  }
-
-  async getWorkspaceQueueDepth(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<number> {
-    if (lanes.length === 0) return 0
-    const pipeline = this.redis.pipeline()
-    for (const lane of lanes) {
-      pipeline.zcard(workspaceLaneKey(workspaceId, lane))
-    }
-    const results = await pipeline.exec()
-    let depth = 0
-    for (const result of results ?? []) {
-      if (result && !result[0]) {
-        depth += (result[1] as number) ?? 0
-      }
-    }
-    return depth
-  }
-
-  async getGlobalQueueDepth(): Promise<number> {
-    const count = await this.redis.get(GLOBAL_DEPTH_KEY)
-    return count ? Math.max(0, Number.parseInt(count, 10)) : 0
-  }
-
-  async reconcileGlobalQueueDepth(knownCount: number): Promise<void> {
-    await this.redis.set(GLOBAL_DEPTH_KEY, knownCount)
-  }
-
-  async popNextWorkspaceId(): Promise<string | null> {
-    const result = await this.redis.zpopmin(ACTIVE_WORKSPACES_KEY)
-    if (!result || result.length === 0) {
-      return null
-    }
-
-    return result[0] ?? null
-  }
-
-  async getQueuedWorkspaceCount(): Promise<number> {
-    return this.redis.zcard(ACTIVE_WORKSPACES_KEY)
-  }
-
-  async hasActiveWorkspace(workspaceId: string): Promise<boolean> {
-    return (await this.redis.zscore(ACTIVE_WORKSPACES_KEY, workspaceId)) !== null
-  }
-
-  async ensureWorkspaceActive(workspaceId: string, readyAt?: number): Promise<void> {
-    const sequence = await this.nextSequence()
-    const score = readyAt && readyAt > Date.now() ? readyAt * 1_000_000 + sequence : sequence
-    await this.redis.zadd(ACTIVE_WORKSPACES_KEY, 'NX', score, workspaceId)
-  }
-
-  async requeueWorkspaceId(workspaceId: string): Promise<void> {
-    const sequence = await this.nextSequence()
-    await this.redis.zadd(ACTIVE_WORKSPACES_KEY, sequence, workspaceId)
-  }
-
-  async workspaceHasPendingJobs(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<boolean> {
-    for (const lane of lanes) {
-      const count = await this.redis.zcard(workspaceLaneKey(workspaceId, lane))
-      if (count > 0) {
-        return true
-      }
-    }
-
-    return false
-  }
-
-  async getNextWorkspaceJob(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<WorkspaceDispatchJobRecord | null> {
-    for (const lane of lanes) {
-      const ids = await this.redis.zrange(workspaceLaneKey(workspaceId, lane), 0, 0)
-      if (ids.length === 0) {
-        continue
-      }
-
-      const record = await this.getDispatchJobRecord(ids[0])
-      if (!record) {
-        await this.redis.zrem(workspaceLaneKey(workspaceId, lane), ids[0])
-        continue
-      }
-
-      return record
-    }
-
-    return null
-  }
-
-  async removeWorkspaceJobFromLane(
-    workspaceId: string,
-    lane: WorkspaceDispatchLane,
-    jobId: string
-  ): Promise<void> {
-    await this.redis.zrem(workspaceLaneKey(workspaceId, lane), jobId)
-  }
-
-  async cleanupExpiredWorkspaceLeases(workspaceId: string): Promise<void> {
-    await this.redis.zremrangebyscore(workspaceLeaseKey(workspaceId), 0, Date.now())
-  }
-
-  async countActiveWorkspaceLeases(workspaceId: string): Promise<number> {
-    await this.cleanupExpiredWorkspaceLeases(workspaceId)
-    return this.redis.zcard(workspaceLeaseKey(workspaceId))
-  }
-
-  async hasWorkspaceLease(workspaceId: string, leaseId: string): Promise<boolean> {
-    await this.cleanupExpiredWorkspaceLeases(workspaceId)
-    return (await this.redis.zscore(workspaceLeaseKey(workspaceId), leaseId)) !== null
-  }
-
-  async createWorkspaceLease(workspaceId: string, leaseId: string, ttlMs: number): Promise<number> {
-    const expiresAt = Date.now() + ttlMs
-    await this.redis.zadd(workspaceLeaseKey(workspaceId), expiresAt, leaseId)
-    return expiresAt
-  }
-
-  async refreshWorkspaceLease(
-    workspaceId: string,
-    leaseId: string,
-    ttlMs: number
-  ): Promise<number> {
-    return this.createWorkspaceLease(workspaceId, leaseId, ttlMs)
-  }
-
-  async releaseWorkspaceLease(workspaceId: string, leaseId: string): Promise<void> {
-    await this.redis.zrem(workspaceLeaseKey(workspaceId), leaseId)
-  }
-
-  async removeWorkspaceIfIdle(
-    workspaceId: string,
-    lanes: readonly WorkspaceDispatchLane[]
-  ): Promise<void> {
-    const hasPendingJobs = await this.workspaceHasPendingJobs(workspaceId, lanes)
-    if (!hasPendingJobs) {
-      await this.redis.zrem(ACTIVE_WORKSPACES_KEY, workspaceId)
-    }
-  }
-
-  async markDispatchJobAdmitted(
-    jobId: string,
-    workspaceId: string,
-    leaseId: string,
-    leaseExpiresAt: number
-  ): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'admitted',
-      admittedAt: Date.now(),
-      lease: {
-        workspaceId,
-        leaseId,
-      },
-      metadata: {
-        ...record.metadata,
-        dispatchLeaseExpiresAt: leaseExpiresAt,
-      },
-    }))
-  }
-
-  async markDispatchJobAdmitting(
-    jobId: string,
-    workspaceId: string,
-    leaseId: string,
-    leaseExpiresAt: number
-  ): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'admitting',
-      lease: {
-        workspaceId,
-        leaseId,
-      },
-      metadata: {
-        ...record.metadata,
-        dispatchLeaseExpiresAt: leaseExpiresAt,
-      },
-    }))
-  }
-
-  async markDispatchJobRunning(jobId: string): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'running',
-      startedAt: record.startedAt ?? Date.now(),
-    }))
-  }
-
-  async markDispatchJobCompleted(jobId: string, output: unknown): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'completed',
-      completedAt: Date.now(),
-      output,
-    }))
-    await this.redis.decr(GLOBAL_DEPTH_KEY).catch(() => undefined)
-  }
-
-  async markDispatchJobFailed(jobId: string, error: string): Promise<void> {
-    await this.updateDispatchJobRecord(jobId, (record) => ({
-      ...record,
-      status: 'failed',
-      completedAt: Date.now(),
-      error,
-    }))
-    await this.redis.decr(GLOBAL_DEPTH_KEY).catch(() => undefined)
-  }
-
-  async clear(): Promise<void> {
-    let cursor = '0'
-    const keys: string[] = []
-
-    do {
-      const [nextCursor, foundKeys] = await this.redis.scan(
-        cursor,
-        'MATCH',
-        `${DISPATCH_PREFIX}:*`,
-        'COUNT',
-        100
-      )
-      cursor = nextCursor
-      keys.push(...foundKeys)
-    } while (cursor !== '0')
-
-    if (keys.length > 0) {
-      await this.redis.del(...keys)
-    }
-  }
-
-  dispose(): void {
-    logger.info('Redis workspace dispatch storage disposed')
-  }
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/status.test.ts b/apps/sim/lib/core/workspace-dispatch/status.test.ts
deleted file mode 100644
index e72e210b18d..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/status.test.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { describe, expect, it } from 'vitest'
-import { presentDispatchOrJobStatus } from '@/lib/core/workspace-dispatch/status'
-
-describe('workspace dispatch status presentation', () => {
-  it('presents waiting dispatch jobs with queue metadata', () => {
-    const result = presentDispatchOrJobStatus(
-      {
-        id: 'dispatch-1',
-        workspaceId: 'workspace-1',
-        lane: 'runtime',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'workflow-execution',
-        bullmqPayload: {},
-        metadata: { workflowId: 'workflow-1' },
-        priority: 10,
-        status: 'waiting',
-        createdAt: 1000,
-      },
-      null
-    )
-
-    expect(result).toEqual({
-      status: 'waiting',
-      metadata: {
-        createdAt: new Date(1000),
-        admittedAt: undefined,
-        startedAt: undefined,
-        completedAt: undefined,
-        queueName: 'workflow-execution',
-        lane: 'runtime',
-        workspaceId: 'workspace-1',
-      },
-      estimatedDuration: 300000,
-    })
-  })
-
-  it('presents admitting dispatch jobs distinctly', () => {
-    const result = presentDispatchOrJobStatus(
-      {
-        id: 'dispatch-1a',
-        workspaceId: 'workspace-1',
-        lane: 'runtime',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'workflow-execution',
-        bullmqPayload: {},
-        metadata: { workflowId: 'workflow-1' },
-        priority: 10,
-        status: 'admitting',
-        createdAt: 1000,
-      },
-      null
-    )
-
-    expect(result.status).toBe('admitting')
-    expect(result.estimatedDuration).toBe(300000)
-  })
-
-  it('presents completed dispatch jobs with output and duration', () => {
-    const result = presentDispatchOrJobStatus(
-      {
-        id: 'dispatch-2',
-        workspaceId: 'workspace-1',
-        lane: 'interactive',
-        queueName: 'workflow-execution',
-        bullmqJobName: 'direct-workflow-execution',
-        bullmqPayload: {},
-        metadata: { workflowId: 'workflow-1' },
-        priority: 1,
-        status: 'completed',
-        createdAt: 1000,
-        admittedAt: 1500,
-        startedAt: 2000,
-        completedAt: 7000,
-        output: { success: true },
-      },
-      null
-    )
-
-    expect(result.status).toBe('completed')
-    expect(result.output).toEqual({ success: true })
-    expect(result.metadata.duration).toBe(5000)
-  })
-
-  it('falls back to legacy job status when no dispatch record exists', () => {
-    const result = presentDispatchOrJobStatus(null, {
-      id: 'job-1',
-      type: 'workflow-execution',
-      payload: {},
-      status: 'pending',
-      createdAt: new Date(1000),
-      attempts: 0,
-      maxAttempts: 3,
-      metadata: {},
-    })
-
-    expect(result.status).toBe('queued')
-    expect(result.estimatedDuration).toBe(300000)
-  })
-})
diff --git a/apps/sim/lib/core/workspace-dispatch/status.ts b/apps/sim/lib/core/workspace-dispatch/status.ts
deleted file mode 100644
index fc5d934434c..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/status.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import type { Job, JobStatus } from '@/lib/core/async-jobs/types'
-import type { WorkspaceDispatchJobRecord } from '@/lib/core/workspace-dispatch/types'
-
-export type DispatchPresentedStatus =
-  | 'waiting'
-  | 'admitting'
-  | 'admitted'
-  | 'running'
-  | 'completed'
-  | 'failed'
-  | 'queued'
-  | JobStatus
-
-export interface DispatchStatusPresentation {
-  status: DispatchPresentedStatus
-  metadata: {
-    createdAt?: Date
-    admittedAt?: Date
-    startedAt?: Date
-    completedAt?: Date
-    queueName?: string
-    lane?: string
-    workspaceId?: string
-    duration?: number
-  }
-  output?: unknown
-  error?: string
-  estimatedDuration?: number
-}
-
-export function presentDispatchOrJobStatus(
-  dispatchJob: WorkspaceDispatchJobRecord | null,
-  job: Job | null
-): DispatchStatusPresentation {
-  if (dispatchJob) {
-    const startedAt = dispatchJob.startedAt ? new Date(dispatchJob.startedAt) : undefined
-    const completedAt = dispatchJob.completedAt ? new Date(dispatchJob.completedAt) : undefined
-
-    const response: DispatchStatusPresentation = {
-      status: dispatchJob.status,
-      metadata: {
-        createdAt: new Date(dispatchJob.createdAt),
-        admittedAt: dispatchJob.admittedAt ? new Date(dispatchJob.admittedAt) : undefined,
-        startedAt,
-        completedAt,
-        queueName: dispatchJob.queueName,
-        lane: dispatchJob.lane,
-        workspaceId: dispatchJob.workspaceId,
-      },
-    }
-
-    if (startedAt && completedAt) {
-      response.metadata.duration = completedAt.getTime() - startedAt.getTime()
-    }
-
-    if (dispatchJob.status === 'completed') {
-      response.output = dispatchJob.output
-    }
-
-    if (dispatchJob.status === 'failed') {
-      response.error = dispatchJob.error
-    }
-
-    if (
-      dispatchJob.status === 'waiting' ||
-      dispatchJob.status === 'admitting' ||
-      dispatchJob.status === 'admitted' ||
-      dispatchJob.status === 'running'
-    ) {
-      response.estimatedDuration = 300000
-    }
-
-    return response
-  }
-
-  if (!job) {
-    return {
-      status: 'queued',
-      metadata: {},
-    }
-  }
-
-  const mappedStatus = job.status === 'pending' ? 'queued' : job.status
-  const response: DispatchStatusPresentation = {
-    status: mappedStatus,
-    metadata: {
-      createdAt: job.createdAt,
-      startedAt: job.startedAt,
-      completedAt: job.completedAt,
-    },
-  }
-
-  if (job.startedAt && job.completedAt) {
-    response.metadata.duration = job.completedAt.getTime() - job.startedAt.getTime()
-  }
-
-  if (job.status === 'completed') {
-    response.output = job.output
-  }
-
-  if (job.status === 'failed') {
-    response.error = job.error
-  }
-
-  if (job.status === 'processing' || job.status === 'pending') {
-    response.estimatedDuration = 300000
-  }
-
-  return response
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/store.ts b/apps/sim/lib/core/workspace-dispatch/store.ts
deleted file mode 100644
index 86c1c3951a9..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/store.ts
+++ /dev/null
@@ -1,193 +0,0 @@
-import type { WorkspaceDispatchStorageAdapter } from '@/lib/core/workspace-dispatch/adapter'
-import {
-  setWorkspaceDispatchStorageAdapter as _setAdapter,
-  createWorkspaceDispatchStorageAdapter,
-} from '@/lib/core/workspace-dispatch/factory'
-import type {
-  WorkspaceDispatchClaimResult,
-  WorkspaceDispatchEnqueueInput,
-  WorkspaceDispatchJobRecord,
-  WorkspaceDispatchLane,
-} from '@/lib/core/workspace-dispatch/types'
-
-function getAdapter() {
-  return createWorkspaceDispatchStorageAdapter()
-}
-
-export function setWorkspaceDispatchStorageAdapter(adapter: WorkspaceDispatchStorageAdapter): void {
-  _setAdapter(adapter)
-}
-
-export async function saveDispatchJob(record: WorkspaceDispatchJobRecord): Promise<void> {
-  return getAdapter().saveDispatchJob(record)
-}
-
-export async function getDispatchJobRecord(
-  jobId: string
-): Promise<WorkspaceDispatchJobRecord | null> {
-  return getAdapter().getDispatchJobRecord(jobId)
-}
-
-export async function listDispatchJobsByStatuses(
-  statuses: readonly WorkspaceDispatchJobRecord['status'][]
-): Promise<WorkspaceDispatchJobRecord[]> {
-  return getAdapter().listDispatchJobsByStatuses(statuses)
-}
-
-export async function updateDispatchJobRecord(
-  jobId: string,
-  updater: (record: WorkspaceDispatchJobRecord) => WorkspaceDispatchJobRecord
-): Promise<WorkspaceDispatchJobRecord | null> {
-  return getAdapter().updateDispatchJobRecord(jobId, updater)
-}
-
-export async function enqueueWorkspaceDispatchJob(
-  input: WorkspaceDispatchEnqueueInput
-): Promise<WorkspaceDispatchJobRecord> {
-  return getAdapter().enqueueWorkspaceDispatchJob(input)
-}
-
-export async function restoreWorkspaceDispatchJob(
-  record: WorkspaceDispatchJobRecord
-): Promise<void> {
-  return getAdapter().restoreWorkspaceDispatchJob(record)
-}
-
-export async function claimWorkspaceJob(
-  workspaceId: string,
-  options: {
-    lanes: readonly WorkspaceDispatchLane[]
-    concurrencyLimit: number
-    leaseId: string
-    now: number
-    leaseTtlMs: number
-  }
-): Promise<WorkspaceDispatchClaimResult> {
-  return getAdapter().claimWorkspaceJob(workspaceId, options)
-}
-
-export async function getWorkspaceQueueDepth(
-  workspaceId: string,
-  lanes: readonly WorkspaceDispatchLane[]
-): Promise<number> {
-  return getAdapter().getWorkspaceQueueDepth(workspaceId, lanes)
-}
-
-export async function getGlobalQueueDepth(): Promise<number> {
-  return getAdapter().getGlobalQueueDepth()
-}
-
-export async function reconcileGlobalQueueDepth(knownCount: number): Promise<void> {
-  return getAdapter().reconcileGlobalQueueDepth(knownCount)
-}
-
-export async function popNextWorkspaceId(): Promise<string | null> {
-  return getAdapter().popNextWorkspaceId()
-}
-
-export async function getQueuedWorkspaceCount(): Promise<number> {
-  return getAdapter().getQueuedWorkspaceCount()
-}
-
-export async function hasActiveWorkspace(workspaceId: string): Promise<boolean> {
-  return getAdapter().hasActiveWorkspace(workspaceId)
-}
-
-export async function ensureWorkspaceActive(workspaceId: string, readyAt?: number): Promise<void> {
-  return getAdapter().ensureWorkspaceActive(workspaceId, readyAt)
-}
-
-export async function requeueWorkspaceId(workspaceId: string): Promise<void> {
-  return getAdapter().requeueWorkspaceId(workspaceId)
-}
-
-export async function workspaceHasPendingJobs(
-  workspaceId: string,
-  lanes: readonly WorkspaceDispatchLane[]
-): Promise<boolean> {
-  return getAdapter().workspaceHasPendingJobs(workspaceId, lanes)
-}
-
-export async function getNextWorkspaceJob(
-  workspaceId: string,
-  lanes: readonly WorkspaceDispatchLane[]
-): Promise<WorkspaceDispatchJobRecord | null> {
-  return getAdapter().getNextWorkspaceJob(workspaceId, lanes)
-}
-
-export async function removeWorkspaceJobFromLane(
-  workspaceId: string,
-  lane: WorkspaceDispatchLane,
-  jobId: string
-): Promise<void> {
-  return getAdapter().removeWorkspaceJobFromLane(workspaceId, lane, jobId)
-}
-
-export async function cleanupExpiredWorkspaceLeases(workspaceId: string): Promise<void> {
-  return getAdapter().cleanupExpiredWorkspaceLeases(workspaceId)
-}
-
-export async function countActiveWorkspaceLeases(workspaceId: string): Promise<number> {
-  return getAdapter().countActiveWorkspaceLeases(workspaceId)
-}
-
-export async function hasWorkspaceLease(workspaceId: string, leaseId: string): Promise<boolean> {
-  return getAdapter().hasWorkspaceLease(workspaceId, leaseId)
-}
-
-export async function createWorkspaceLease(
-  workspaceId: string,
-  leaseId: string,
-  ttlMs: number
-): Promise<number> {
-  return getAdapter().createWorkspaceLease(workspaceId, leaseId, ttlMs)
-}
-
-export async function refreshWorkspaceLease(
-  workspaceId: string,
-  leaseId: string,
-  ttlMs: number
-): Promise<number> {
-  return getAdapter().refreshWorkspaceLease(workspaceId, leaseId, ttlMs)
-}
-
-export async function releaseWorkspaceLease(workspaceId: string, leaseId: string): Promise<void> {
-  return getAdapter().releaseWorkspaceLease(workspaceId, leaseId)
-}
-
-export async function removeWorkspaceIfIdle(
-  workspaceId: string,
-  lanes: readonly WorkspaceDispatchLane[]
-): Promise<void> {
-  return getAdapter().removeWorkspaceIfIdle(workspaceId, lanes)
-}
-
-export async function markDispatchJobAdmitted(
-  jobId: string,
-  workspaceId: string,
-  leaseId: string,
-  leaseExpiresAt: number
-): Promise<void> {
-  return getAdapter().markDispatchJobAdmitted(jobId, workspaceId, leaseId, leaseExpiresAt)
-}
-
-export async function markDispatchJobAdmitting(
-  jobId: string,
-  workspaceId: string,
-  leaseId: string,
-  leaseExpiresAt: number
-): Promise<void> {
-  return getAdapter().markDispatchJobAdmitting(jobId, workspaceId, leaseId, leaseExpiresAt)
-}
-
-export async function markDispatchJobRunning(jobId: string): Promise<void> {
-  return getAdapter().markDispatchJobRunning(jobId)
-}
-
-export async function markDispatchJobCompleted(jobId: string, output: unknown): Promise<void> {
-  return getAdapter().markDispatchJobCompleted(jobId, output)
-}
-
-export async function markDispatchJobFailed(jobId: string, error: string): Promise<void> {
-  return getAdapter().markDispatchJobFailed(jobId, error)
-}
diff --git a/apps/sim/lib/core/workspace-dispatch/types.ts b/apps/sim/lib/core/workspace-dispatch/types.ts
deleted file mode 100644
index 87218956644..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/types.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import type { JobMetadata, JobType } from '@/lib/core/async-jobs/types'
-import type {
-  KNOWLEDGE_CONNECTOR_SYNC_QUEUE,
-  KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE,
-  MOTHERSHIP_JOB_EXECUTION_QUEUE,
-  WORKSPACE_NOTIFICATION_DELIVERY_QUEUE,
-} from '@/lib/core/bullmq/queues'
-
-export const WORKSPACE_DISPATCH_LANES = [
-  'interactive',
-  'runtime',
-  'knowledge',
-  'lightweight',
-] as const
-
-export type WorkspaceDispatchLane = (typeof WORKSPACE_DISPATCH_LANES)[number]
-
-export type WorkspaceDispatchQueueName =
-  | JobType
-  | typeof KNOWLEDGE_CONNECTOR_SYNC_QUEUE
-  | typeof KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE
-  | typeof MOTHERSHIP_JOB_EXECUTION_QUEUE
-  | typeof WORKSPACE_NOTIFICATION_DELIVERY_QUEUE
-
-export const WORKSPACE_DISPATCH_STATUSES = {
-  WAITING: 'waiting',
-  ADMITTING: 'admitting',
-  ADMITTED: 'admitted',
-  RUNNING: 'running',
-  COMPLETED: 'completed',
-  FAILED: 'failed',
-} as const
-
-export type WorkspaceDispatchStatus =
-  (typeof WORKSPACE_DISPATCH_STATUSES)[keyof typeof WORKSPACE_DISPATCH_STATUSES]
-
-export interface WorkspaceDispatchLeaseInfo {
-  workspaceId: string
-  leaseId: string
-}
-
-export interface WorkspaceDispatchJobContext {
-  dispatchJobId: string
-  workspaceId: string
-  lane: WorkspaceDispatchLane
-  queueName: WorkspaceDispatchQueueName
-  bullmqJobName: string
-  priority: number
-}
-
-export interface WorkspaceDispatchJobRecord {
-  id: string
-  workspaceId: string
-  lane: WorkspaceDispatchLane
-  queueName: WorkspaceDispatchQueueName
-  bullmqJobName: string
-  bullmqPayload: unknown
-  metadata: JobMetadata
-  priority: number
-  maxAttempts?: number
-  delayMs?: number
-  status: WorkspaceDispatchStatus
-  createdAt: number
-  admittedAt?: number
-  startedAt?: number
-  completedAt?: number
-  output?: unknown
-  error?: string
-  lease?: WorkspaceDispatchLeaseInfo
-}
-
-export interface WorkspaceDispatchEnqueueInput {
-  id?: string
-  workspaceId: string
-  lane: WorkspaceDispatchLane
-  queueName: WorkspaceDispatchQueueName
-  bullmqJobName: string
-  bullmqPayload: unknown
-  metadata: JobMetadata
-  priority?: number
-  maxAttempts?: number
-  delayMs?: number
-}
-
-export const WORKSPACE_DISPATCH_CLAIM_RESULTS = {
-  ADMITTED: 'admitted',
-  LIMIT_REACHED: 'limit_reached',
-  DELAYED: 'delayed',
-  EMPTY: 'empty',
-} as const
-
-export type WorkspaceDispatchClaimResult =
-  | {
-      type: typeof WORKSPACE_DISPATCH_CLAIM_RESULTS.ADMITTED
-      record: WorkspaceDispatchJobRecord
-      leaseId: string
-      leaseExpiresAt: number
-    }
-  | {
-      type:
-        | typeof WORKSPACE_DISPATCH_CLAIM_RESULTS.LIMIT_REACHED
-        | typeof WORKSPACE_DISPATCH_CLAIM_RESULTS.EMPTY
-    }
-  | {
-      type: typeof WORKSPACE_DISPATCH_CLAIM_RESULTS.DELAYED
-      nextReadyAt: number
-    }
diff --git a/apps/sim/lib/core/workspace-dispatch/worker.test.ts b/apps/sim/lib/core/workspace-dispatch/worker.test.ts
deleted file mode 100644
index 1833b128cdd..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/worker.test.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const {
-  mockMarkDispatchJobCompleted,
-  mockMarkDispatchJobFailed,
-  mockMarkDispatchJobRunning,
-  mockReleaseWorkspaceLease,
-  mockWakeWorkspaceDispatcher,
-} = vi.hoisted(() => ({
-  mockMarkDispatchJobCompleted: vi.fn(),
-  mockMarkDispatchJobFailed: vi.fn(),
-  mockMarkDispatchJobRunning: vi.fn(),
-  mockReleaseWorkspaceLease: vi.fn(),
-  mockWakeWorkspaceDispatcher: vi.fn(),
-}))
-
-vi.mock('@sim/logger', () => ({
-  createLogger: () => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-  }),
-}))
-
-vi.mock('@/lib/core/workspace-dispatch', () => ({
-  markDispatchJobCompleted: mockMarkDispatchJobCompleted,
-  markDispatchJobFailed: mockMarkDispatchJobFailed,
-  markDispatchJobRunning: mockMarkDispatchJobRunning,
-  releaseWorkspaceLease: mockReleaseWorkspaceLease,
-  wakeWorkspaceDispatcher: mockWakeWorkspaceDispatcher,
-}))
-
-import { getDispatchRuntimeMetadata, runDispatchedJob } from '@/lib/core/workspace-dispatch/worker'
-
-describe('workspace dispatch worker lifecycle', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('returns null for missing metadata', () => {
-    expect(getDispatchRuntimeMetadata(undefined)).toBeNull()
-  })
-
-  it('extracts dispatch runtime metadata when all fields are present', () => {
-    expect(
-      getDispatchRuntimeMetadata({
-        dispatchJobId: 'dispatch-1',
-        dispatchWorkspaceId: 'workspace-1',
-        dispatchLeaseId: 'lease-1',
-      })
-    ).toEqual({
-      dispatchJobId: 'dispatch-1',
-      dispatchWorkspaceId: 'workspace-1',
-      dispatchLeaseId: 'lease-1',
-    })
-  })
-
-  it('marks running, completed, releases lease, and wakes dispatcher on success', async () => {
-    const result = await runDispatchedJob(
-      {
-        dispatchJobId: 'dispatch-1',
-        dispatchWorkspaceId: 'workspace-1',
-        dispatchLeaseId: 'lease-1',
-      },
-      async () => ({ success: true })
-    )
-
-    expect(result).toEqual({ success: true })
-    expect(mockMarkDispatchJobRunning).toHaveBeenCalledWith('dispatch-1')
-    expect(mockMarkDispatchJobCompleted).toHaveBeenCalledWith('dispatch-1', { success: true })
-    expect(mockReleaseWorkspaceLease).toHaveBeenCalledWith('workspace-1', 'lease-1')
-    expect(mockWakeWorkspaceDispatcher).toHaveBeenCalled()
-  })
-
-  it('marks failed and still releases lease on error', async () => {
-    await expect(
-      runDispatchedJob(
-        {
-          dispatchJobId: 'dispatch-2',
-          dispatchWorkspaceId: 'workspace-2',
-          dispatchLeaseId: 'lease-2',
-        },
-        async () => {
-          throw new Error('boom')
-        }
-      )
-    ).rejects.toThrow('boom')
-
-    expect(mockMarkDispatchJobRunning).toHaveBeenCalledWith('dispatch-2')
-    expect(mockMarkDispatchJobFailed).toHaveBeenCalledWith('dispatch-2', 'boom')
-    expect(mockReleaseWorkspaceLease).toHaveBeenCalledWith('workspace-2', 'lease-2')
-    expect(mockWakeWorkspaceDispatcher).toHaveBeenCalled()
-  })
-})
diff --git a/apps/sim/lib/core/workspace-dispatch/worker.ts b/apps/sim/lib/core/workspace-dispatch/worker.ts
deleted file mode 100644
index ced31a599a3..00000000000
--- a/apps/sim/lib/core/workspace-dispatch/worker.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { createLogger } from '@sim/logger'
-import {
-  markDispatchJobCompleted,
-  markDispatchJobFailed,
-  markDispatchJobRunning,
-  refreshWorkspaceLease,
-  releaseWorkspaceLease,
-  wakeWorkspaceDispatcher,
-} from '@/lib/core/workspace-dispatch'
-
-const logger = createLogger('WorkspaceDispatchWorker')
-
-interface DispatchRuntimeMetadata {
-  dispatchJobId: string
-  dispatchWorkspaceId: string
-  dispatchLeaseId: string
-}
-
-interface RunDispatchedJobOptions {
-  isFinalAttempt?: boolean
-  leaseTtlMs?: number
-}
-
-const DEFAULT_LEASE_TTL_MS = 15 * 60 * 1000
-const LEASE_HEARTBEAT_INTERVAL_MS = 60_000
-
-export function getDispatchRuntimeMetadata(metadata: unknown): DispatchRuntimeMetadata | null {
-  if (!metadata || typeof metadata !== 'object') {
-    return null
-  }
-
-  const value = metadata as Partial<DispatchRuntimeMetadata>
-  if (!value.dispatchJobId || !value.dispatchWorkspaceId || !value.dispatchLeaseId) {
-    return null
-  }
-
-  return {
-    dispatchJobId: value.dispatchJobId,
-    dispatchWorkspaceId: value.dispatchWorkspaceId,
-    dispatchLeaseId: value.dispatchLeaseId,
-  }
-}
-
-export async function runDispatchedJob<T>(
-  metadata: unknown,
-  run: () => Promise<T>,
-  options: RunDispatchedJobOptions = {}
-): Promise<T> {
-  const dispatchMetadata = getDispatchRuntimeMetadata(metadata)
-
-  if (!dispatchMetadata) {
-    return run()
-  }
-
-  const leaseTtlMs = options.leaseTtlMs ?? DEFAULT_LEASE_TTL_MS
-  const isFinalAttempt = options.isFinalAttempt ?? true
-
-  await markDispatchJobRunning(dispatchMetadata.dispatchJobId)
-
-  let heartbeatTimer: NodeJS.Timeout | null = setInterval(() => {
-    void refreshWorkspaceLease(
-      dispatchMetadata.dispatchWorkspaceId,
-      dispatchMetadata.dispatchLeaseId,
-      leaseTtlMs
-    ).catch((error) => {
-      logger.error('Failed to refresh dispatch lease', { error, dispatchMetadata })
-    })
-  }, LEASE_HEARTBEAT_INTERVAL_MS)
-  heartbeatTimer.unref()
-
-  let succeeded = false
-  try {
-    const result = await run()
-    succeeded = true
-    await markDispatchJobCompleted(dispatchMetadata.dispatchJobId, result)
-    return result
-  } catch (error) {
-    if (isFinalAttempt && !succeeded) {
-      await markDispatchJobFailed(
-        dispatchMetadata.dispatchJobId,
-        error instanceof Error ? error.message : String(error)
-      )
-    }
-    throw error
-  } finally {
-    if (heartbeatTimer) {
-      clearInterval(heartbeatTimer)
-      heartbeatTimer = null
-    }
-
-    const shouldReleaseLease = succeeded || isFinalAttempt
-    if (shouldReleaseLease) {
-      try {
-        await releaseWorkspaceLease(
-          dispatchMetadata.dispatchWorkspaceId,
-          dispatchMetadata.dispatchLeaseId
-        )
-        await wakeWorkspaceDispatcher()
-      } catch (error) {
-        logger.error('Failed to release dispatch lease', { error, dispatchMetadata })
-      }
-    }
-  }
-}
diff --git a/apps/sim/lib/environment/utils.ts b/apps/sim/lib/environment/utils.ts
index 9b1b37900ff..21216d8b069 100644
--- a/apps/sim/lib/environment/utils.ts
+++ b/apps/sim/lib/environment/utils.ts
@@ -11,6 +11,19 @@ import {
 } from '@/lib/credentials/environment'
 
 const logger = createLogger('EnvironmentUtils')
+const EFFECTIVE_ENV_CACHE_TTL_MS = 15_000
+
+type EffectiveEnvCacheEntry = {
+  expiresAt: number
+  value?: Record<string, string>
+  promise?: Promise<Record<string, string>>
+}
+
+const effectiveEnvCache = new Map<string, EffectiveEnvCacheEntry>()
+
+function getEffectiveEnvCacheKey(userId: string, workspaceId?: string) {
+  return `${userId}:${workspaceId ?? ''}`
+}
 
 /**
  * Get environment variable keys for a user
@@ -301,9 +314,38 @@ export async function getEffectiveDecryptedEnv(
   userId: string,
   workspaceId?: string
 ): Promise<Record<string, string>> {
-  const { personalDecrypted, workspaceDecrypted } = await getPersonalAndWorkspaceEnv(
-    userId,
-    workspaceId
-  )
-  return { ...personalDecrypted, ...workspaceDecrypted }
+  const cacheKey = getEffectiveEnvCacheKey(userId, workspaceId)
+  const now = Date.now()
+  const cached = effectiveEnvCache.get(cacheKey)
+
+  if (cached?.value && cached.expiresAt > now) {
+    return { ...cached.value }
+  }
+
+  if (cached?.promise) {
+    const value = await cached.promise
+    return { ...value }
+  }
+
+  const promise = getPersonalAndWorkspaceEnv(userId, workspaceId)
+    .then(({ personalDecrypted, workspaceDecrypted }) => {
+      const value = { ...personalDecrypted, ...workspaceDecrypted }
+      effectiveEnvCache.set(cacheKey, {
+        value,
+        expiresAt: Date.now() + EFFECTIVE_ENV_CACHE_TTL_MS,
+      })
+      return value
+    })
+    .catch((error) => {
+      effectiveEnvCache.delete(cacheKey)
+      throw error
+    })
+
+  effectiveEnvCache.set(cacheKey, {
+    expiresAt: now + EFFECTIVE_ENV_CACHE_TTL_MS,
+    promise,
+  })
+
+  const value = await promise
+  return { ...value }
 }
diff --git a/apps/sim/lib/execution/doc-vm.ts b/apps/sim/lib/execution/doc-vm.ts
new file mode 100644
index 00000000000..2620f2e47cf
--- /dev/null
+++ b/apps/sim/lib/execution/doc-vm.ts
@@ -0,0 +1,211 @@
+/**
+ * Sandboxed document generation via subprocess.
+ *
+ * Supports pptx (pptxgenjs), docx (docx), and pdf (pdf-lib).
+ * User code runs in a separate Node.js child process. File access is brokered
+ * via IPC -- the subprocess never touches the database directly.
+ */
+
+import { type ChildProcess, spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createLogger } from '@sim/logger'
+import {
+  downloadWorkspaceFile,
+  getWorkspaceFile,
+} from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+
+const logger = createLogger('DocVMExecution')
+
+export type DocumentFormat = 'pptx' | 'docx' | 'pdf'
+
+const WORKER_STARTUP_TIMEOUT_MS = 10_000
+const GENERATION_TIMEOUT_MS = 60_000
+const MAX_STDERR = 4096
+
+type WorkerMessage =
+  | { type: 'ready' }
+  | { type: 'result'; data: string }
+  | { type: 'error'; message: string }
+  | { type: 'getFile'; fileReqId: number; fileId: string }
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+let cachedWorkerPath: string | undefined
+
+function getWorkerPath(): string {
+  if (cachedWorkerPath) return cachedWorkerPath
+  const candidates = [
+    path.join(currentDir, '..', '..', 'dist', 'doc-worker.cjs'),
+    path.join(currentDir, 'doc-worker.cjs'),
+    path.join(process.cwd(), 'apps', 'sim', 'dist', 'doc-worker.cjs'),
+    path.join(process.cwd(), 'apps', 'sim', 'lib', 'execution', 'doc-worker.cjs'),
+    path.join(process.cwd(), 'dist', 'doc-worker.cjs'),
+    path.join(process.cwd(), 'lib', 'execution', 'doc-worker.cjs'),
+  ]
+  const found = candidates.find((p) => fs.existsSync(p))
+  if (!found) throw new Error(`doc-worker.cjs not found at any of: ${candidates.join(', ')}`)
+  cachedWorkerPath = found
+  return found
+}
+
+export async function generateDocumentFromCode(
+  format: DocumentFormat,
+  code: string,
+  workspaceId: string,
+  signal?: AbortSignal
+): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    let proc: ChildProcess | null = null
+    let settled = false
+    let startupTimer: ReturnType<typeof setTimeout> | null = null
+    let generationTimer: ReturnType<typeof setTimeout> | null = null
+
+    function done(err: Error): void
+    function done(err: undefined, result: Buffer): void
+    function done(err: Error | undefined, result?: Buffer): void {
+      if (settled) return
+      settled = true
+      if (startupTimer) clearTimeout(startupTimer)
+      if (generationTimer) clearTimeout(generationTimer)
+      try {
+        proc?.removeAllListeners()
+        proc?.kill()
+      } catch {
+        // Ignore -- process may have already exited
+      }
+      if (err) reject(err)
+      else resolve(result as Buffer)
+    }
+
+    if (signal?.aborted) {
+      reject(new Error(`${format.toUpperCase()} generation cancelled`))
+      return
+    }
+
+    signal?.addEventListener(
+      'abort',
+      () => done(new Error(`${format.toUpperCase()} generation cancelled`)),
+      { once: true }
+    )
+
+    try {
+      proc = spawn('node', [getWorkerPath()], {
+        stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        serialization: 'json',
+        env: { PATH: process.env.PATH ?? '' } as unknown as NodeJS.ProcessEnv,
+      })
+    } catch (err) {
+      done(err instanceof Error ? err : new Error(String(err)))
+      return
+    }
+
+    let stderrData = ''
+    proc.stderr?.on('data', (chunk: Buffer) => {
+      if (stderrData.length < MAX_STDERR) {
+        stderrData += chunk.toString()
+        if (stderrData.length > MAX_STDERR) stderrData = stderrData.slice(0, MAX_STDERR)
+      }
+    })
+
+    startupTimer = setTimeout(() => {
+      logger.error(`${format} worker failed to start within timeout`)
+      done(new Error(`${format.toUpperCase()} worker failed to start`))
+    }, WORKER_STARTUP_TIMEOUT_MS)
+
+    proc.on('exit', (code) => {
+      if (!settled) {
+        logger.error(`${format} worker exited unexpectedly`, {
+          code,
+          stderr: stderrData.slice(0, 500),
+        })
+        done(new Error(`${format.toUpperCase()} worker exited unexpectedly (code ${code})`))
+      }
+    })
+
+    proc.on('error', (err) => {
+      logger.error(`${format} worker process error`, { error: err.message })
+      done(err)
+    })
+
+    proc.on('message', (rawMsg: unknown) => {
+      const msg = rawMsg as WorkerMessage
+
+      if (msg.type === 'ready') {
+        if (startupTimer) {
+          clearTimeout(startupTimer)
+          startupTimer = null
+        }
+        generationTimer = setTimeout(() => {
+          logger.error(`${format} generation timed out`)
+          done(new Error(`${format.toUpperCase()} generation timed out`))
+        }, GENERATION_TIMEOUT_MS)
+        proc!.send({ type: 'generate', format, code })
+        return
+      }
+
+      if (msg.type === 'result') {
+        done(undefined, Buffer.from(msg.data, 'base64'))
+        return
+      }
+
+      if (msg.type === 'error') {
+        done(new Error(msg.message))
+        return
+      }
+
+      if (msg.type === 'getFile') {
+        handleFileRequest(proc!, workspaceId, msg).catch((err) => {
+          logger.error(`Failed to handle file request from ${format} worker`, {
+            fileId: msg.fileId,
+            error: err instanceof Error ? err.message : String(err),
+          })
+          if (proc && !settled) {
+            try {
+              proc.send({
+                type: 'fileResult',
+                fileReqId: msg.fileReqId,
+                error: err instanceof Error ? err.message : 'File fetch failed',
+              })
+            } catch {
+              // Ignore -- process may have died
+            }
+          }
+        })
+      }
+    })
+  })
+}
+
+async function handleFileRequest(
+  proc: ChildProcess,
+  workspaceId: string,
+  msg: Extract<WorkerMessage, { type: 'getFile' }>
+): Promise<void> {
+  const record = await getWorkspaceFile(workspaceId, msg.fileId)
+  if (!record) {
+    proc.send({
+      type: 'fileResult',
+      fileReqId: msg.fileReqId,
+      error: `File not found: ${msg.fileId}`,
+    })
+    return
+  }
+
+  const buffer = await downloadWorkspaceFile(record)
+  const mime = record.type || 'image/png'
+  proc.send({
+    type: 'fileResult',
+    fileReqId: msg.fileReqId,
+    data: `data:${mime};base64,${buffer.toString('base64')}`,
+  })
+}
+
+export const generatePptxFromCode = (code: string, workspaceId: string, signal?: AbortSignal) =>
+  generateDocumentFromCode('pptx', code, workspaceId, signal)
+
+export const generateDocxFromCode = (code: string, workspaceId: string, signal?: AbortSignal) =>
+  generateDocumentFromCode('docx', code, workspaceId, signal)
+
+export const generatePdfFromCode = (code: string, workspaceId: string, signal?: AbortSignal) =>
+  generateDocumentFromCode('pdf', code, workspaceId, signal)
diff --git a/apps/sim/lib/execution/doc-worker.cjs b/apps/sim/lib/execution/doc-worker.cjs
new file mode 100644
index 00000000000..6290653917f
--- /dev/null
+++ b/apps/sim/lib/execution/doc-worker.cjs
@@ -0,0 +1,162 @@
+/**
+ * Generic document generation worker.
+ * Runs in a separate Node.js process, communicates with parent via IPC.
+ * Supports pptx (pptxgenjs), docx (docx), and pdf (pdf-lib).
+ */
+
+'use strict'
+
+const vm = require('node:vm')
+
+const EXECUTION_TIMEOUT_MS = 30_000
+const FILE_REQUEST_TIMEOUT_MS = 30_000
+
+const FORMATS = {
+  pptx: {
+    setup() {
+      const PptxGenJS = require('pptxgenjs')
+      const pptx = new PptxGenJS()
+      return { globals: { pptx }, pptx }
+    },
+    async serialize(ctx) {
+      const output = await ctx.pptx.write({ outputType: 'nodebuffer' })
+      return Buffer.from(output)
+    },
+  },
+  docx: {
+    setup() {
+      const docx = require('docx')
+      const _sections = []
+      return { globals: { docx, addSection: (s) => _sections.push(s) }, _sections, docx }
+    },
+    async serialize(ctx) {
+      if (ctx.globals.doc) {
+        return ctx.docx.Packer.toBuffer(ctx.globals.doc)
+      }
+      if (ctx._sections.length > 0) {
+        const doc = new ctx.docx.Document({ sections: ctx._sections })
+        return ctx.docx.Packer.toBuffer(doc)
+      }
+      throw new Error(
+        'No document created. Use addSection({ children: [...] }) for chunked writes, or set doc = new docx.Document({...}) for a single write.'
+      )
+    },
+  },
+  pdf: {
+    async setup() {
+      const PDFLib = require('pdf-lib')
+      const pdf = await PDFLib.PDFDocument.create()
+
+      async function embedImage(dataUri) {
+        const base64 = dataUri.split(',')[1]
+        const bytes = Buffer.from(base64, 'base64')
+        const mime = dataUri.split(';')[0].split(':')[1] || ''
+        if (mime.includes('png')) return pdf.embedPng(bytes)
+        return pdf.embedJpg(bytes)
+      }
+
+      return { globals: { PDFLib, pdf, embedImage }, pdf }
+    },
+    async serialize(ctx) {
+      const pdf = ctx.globals.pdf
+      if (!pdf)
+        throw new Error(
+          'No PDF document. Use the injected pdf object or load one with PDFLib.PDFDocument.load().'
+        )
+      const bytes = await pdf.save()
+      return Buffer.from(bytes)
+    },
+  },
+}
+
+const pendingFileRequests = new Map()
+let fileRequestCounter = 0
+
+function sendToParent(msg) {
+  if (process.send && process.connected) {
+    process.send(msg)
+    return true
+  }
+  return false
+}
+
+process.on('message', async (msg) => {
+  if (msg.type === 'generate') {
+    await handleGenerate(msg)
+  } else if (msg.type === 'fileResult') {
+    handleFileResult(msg)
+  }
+})
+
+async function handleGenerate(msg) {
+  const { code, format } = msg
+
+  try {
+    const formatConfig = FORMATS[format]
+    if (!formatConfig) throw new Error(`Unknown document format: ${format}`)
+
+    const ctx = await formatConfig.setup()
+
+    const getFileBase64 = (fileId) =>
+      new Promise((resolve, reject) => {
+        if (typeof fileId !== 'string' || fileId.length === 0) {
+          reject(new Error('fileId must be a non-empty string'))
+          return
+        }
+
+        const fileReqId = ++fileRequestCounter
+        const timeout = setTimeout(() => {
+          if (pendingFileRequests.has(fileReqId)) {
+            pendingFileRequests.delete(fileReqId)
+            reject(new Error(`File request timed out for fileId: ${fileId}`))
+          }
+        }, FILE_REQUEST_TIMEOUT_MS)
+
+        pendingFileRequests.set(fileReqId, { resolve, reject, timeout })
+
+        if (!sendToParent({ type: 'getFile', fileReqId, fileId })) {
+          clearTimeout(timeout)
+          pendingFileRequests.delete(fileReqId)
+          reject(new Error('Parent process disconnected'))
+        }
+      })
+
+    const sandbox = Object.create(null)
+    Object.assign(sandbox, ctx.globals)
+    sandbox.getFileBase64 = getFileBase64
+
+    vm.createContext(sandbox)
+
+    const promise = vm.runInContext(`(async () => { ${code} })()`, sandbox, {
+      timeout: EXECUTION_TIMEOUT_MS,
+      filename: `${format}-code.js`,
+    })
+    await promise
+
+    ctx.globals = sandbox
+
+    const output = await formatConfig.serialize(ctx)
+    const base64 = Buffer.from(output).toString('base64')
+    sendToParent({ type: 'result', data: base64 })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    sendToParent({ type: 'error', message })
+  }
+}
+
+function handleFileResult(msg) {
+  const { fileReqId, data, error } = msg
+  const pending = pendingFileRequests.get(fileReqId)
+  if (!pending) return
+
+  clearTimeout(pending.timeout)
+  pendingFileRequests.delete(fileReqId)
+
+  if (error) {
+    pending.reject(new Error(error))
+  } else {
+    pending.resolve(data)
+  }
+}
+
+sendToParent({ type: 'ready' })
diff --git a/apps/sim/lib/execution/e2b.ts b/apps/sim/lib/execution/e2b.ts
index f312fc21e4a..1338b35d28f 100644
--- a/apps/sim/lib/execution/e2b.ts
+++ b/apps/sim/lib/execution/e2b.ts
@@ -6,6 +6,7 @@ import { CodeLanguage } from '@/lib/execution/languages'
 export interface SandboxFile {
   path: string
   content: string
+  encoding?: 'base64'
 }
 
 export interface E2BExecutionRequest {
@@ -13,6 +14,15 @@ export interface E2BExecutionRequest {
   language: CodeLanguage
   timeoutMs: number
   sandboxFiles?: SandboxFile[]
+  outputSandboxPath?: string
+}
+
+export interface E2BShellExecutionRequest {
+  code: string
+  envs: Record<string, string>
+  timeoutMs: number
+  sandboxFiles?: SandboxFile[]
+  outputSandboxPath?: string
 }
 
 export interface E2BExecutionResult {
@@ -20,6 +30,7 @@ export interface E2BExecutionResult {
   stdout: string
   sandboxId?: string
   error?: string
+  exportedFileContent?: string
   /** Base64-encoded PNG images captured from rich outputs (e.g. matplotlib figures). */
   images?: string[]
 }
@@ -27,7 +38,7 @@ export interface E2BExecutionResult {
 const logger = createLogger('E2BExecution')
 
 export async function executeInE2B(req: E2BExecutionRequest): Promise<E2BExecutionResult> {
-  const { code, language, timeoutMs } = req
+  const { code, language, timeoutMs, outputSandboxPath } = req
 
   const apiKey = env.E2B_API_KEY
   if (!apiKey) {
@@ -39,7 +50,15 @@ export async function executeInE2B(req: E2BExecutionRequest): Promise<E2BExecuti
 
   if (req.sandboxFiles?.length) {
     for (const file of req.sandboxFiles) {
-      await sandbox.files.write(file.path, file.content)
+      if (file.encoding === 'base64') {
+        const buf = Buffer.from(file.content, 'base64')
+        await sandbox.files.write(
+          file.path,
+          buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+        )
+      } else {
+        await sandbox.files.write(file.path, file.content)
+      }
     }
     logger.info('Wrote sandbox input files', {
       sandboxId,
@@ -115,7 +134,175 @@ export async function executeInE2B(req: E2BExecutionRequest): Promise<E2BExecuti
       }
     }
 
-    return { result, stdout: cleanedStdout, sandboxId, images: images.length ? images : undefined }
+    let exportedFileContent: string | undefined
+    if (outputSandboxPath) {
+      const ext = outputSandboxPath.slice(outputSandboxPath.lastIndexOf('.')).toLowerCase()
+      const binaryExts = new Set([
+        '.png',
+        '.jpg',
+        '.jpeg',
+        '.gif',
+        '.webp',
+        '.pdf',
+        '.zip',
+        '.mp3',
+        '.mp4',
+        '.docx',
+        '.pptx',
+        '.xlsx',
+      ])
+      if (binaryExts.has(ext)) {
+        const b64Result = await sandbox.commands.run(`base64 -w0 "${outputSandboxPath}"`)
+        exportedFileContent = b64Result.stdout
+      } else {
+        exportedFileContent = await sandbox.files.read(outputSandboxPath)
+      }
+    }
+
+    return {
+      result,
+      stdout: cleanedStdout,
+      sandboxId,
+      exportedFileContent,
+      images: images.length ? images : undefined,
+    }
+  } finally {
+    try {
+      await sandbox.kill()
+    } catch {}
+  }
+}
+
+export async function executeShellInE2B(
+  req: E2BShellExecutionRequest
+): Promise<E2BExecutionResult> {
+  const { code, envs, timeoutMs, outputSandboxPath } = req
+
+  const apiKey = env.E2B_API_KEY
+  if (!apiKey) {
+    throw new Error('E2B_API_KEY is required when E2B is enabled')
+  }
+
+  const templateName = env.MOTHERSHIP_E2B_TEMPLATE_ID
+  logger.info('Creating E2B shell sandbox', {
+    template: templateName || '(default)',
+  })
+  const sandbox = templateName
+    ? await Sandbox.create(templateName, { apiKey })
+    : await Sandbox.create({ apiKey })
+  const sandboxId = sandbox.sandboxId
+
+  if (req.sandboxFiles?.length) {
+    for (const file of req.sandboxFiles) {
+      if (file.encoding === 'base64') {
+        const buf = Buffer.from(file.content, 'base64')
+        await sandbox.files.write(
+          file.path,
+          buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+        )
+      } else {
+        await sandbox.files.write(file.path, file.content)
+      }
+    }
+    logger.info('Wrote sandbox input files', {
+      sandboxId,
+      fileCount: req.sandboxFiles.length,
+      paths: req.sandboxFiles.map((f) => f.path),
+    })
+  }
+
+  try {
+    let result: { stdout: string; stderr: string; exitCode: number }
+    try {
+      result = await sandbox.commands.run(code, {
+        envs: {
+          ...envs,
+          PATH: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/root/.local/bin',
+        },
+        timeoutMs,
+        user: 'root',
+      })
+    } catch (cmdError: any) {
+      const stderr = cmdError?.stderr || cmdError?.message || String(cmdError)
+      const stdout = cmdError?.stdout || ''
+      const exitCode = cmdError?.exitCode ?? 1
+      logger.error('E2B shell command error', {
+        sandboxId,
+        exitCode,
+        error: stderr.slice(0, 500),
+      })
+      return {
+        result: null,
+        stdout: [stdout, stderr].filter(Boolean).join('\n'),
+        error: stderr || `Command failed with exit code ${exitCode}`,
+        sandboxId,
+      }
+    }
+
+    const stdout = [result.stdout, result.stderr].filter(Boolean).join('\n')
+
+    if (result.exitCode !== 0) {
+      const errorMessage = result.stderr || `Process exited with code ${result.exitCode}`
+      logger.error('E2B shell execution error', {
+        sandboxId,
+        exitCode: result.exitCode,
+        stderr: result.stderr?.slice(0, 500),
+      })
+      return {
+        result: null,
+        stdout,
+        error: errorMessage,
+        sandboxId,
+      }
+    }
+
+    let parsed: unknown = null
+    const prefix = '__SIM_RESULT__='
+    const lines = stdout.split('\n')
+    const marker = lines.find((l) => l.startsWith(prefix))
+    let cleanedStdout = stdout
+    if (marker) {
+      const jsonPart = marker.slice(prefix.length)
+      try {
+        parsed = JSON.parse(jsonPart)
+      } catch {
+        parsed = jsonPart
+      }
+      const filteredLines = lines.filter((l) => !l.startsWith(prefix))
+      if (filteredLines.length > 0 && filteredLines[filteredLines.length - 1] === '') {
+        filteredLines.pop()
+      }
+      cleanedStdout = filteredLines.join('\n')
+    }
+
+    let exportedFileContent: string | undefined
+    if (outputSandboxPath) {
+      const ext = outputSandboxPath.slice(outputSandboxPath.lastIndexOf('.')).toLowerCase()
+      const binaryExts = new Set([
+        '.png',
+        '.jpg',
+        '.jpeg',
+        '.gif',
+        '.webp',
+        '.pdf',
+        '.zip',
+        '.mp3',
+        '.mp4',
+        '.docx',
+        '.pptx',
+        '.xlsx',
+      ])
+      if (binaryExts.has(ext)) {
+        const b64Result = await sandbox.commands.run(`base64 -w0 "${outputSandboxPath}"`, {
+          user: 'root',
+        })
+        exportedFileContent = b64Result.stdout
+      } else {
+        exportedFileContent = await sandbox.files.read(outputSandboxPath)
+      }
+    }
+
+    return { result: parsed, stdout: cleanedStdout, sandboxId, exportedFileContent }
   } finally {
     try {
       await sandbox.kill()
diff --git a/apps/sim/lib/execution/languages.ts b/apps/sim/lib/execution/languages.ts
index e25b991dd03..e664f23de96 100644
--- a/apps/sim/lib/execution/languages.ts
+++ b/apps/sim/lib/execution/languages.ts
@@ -4,6 +4,7 @@
 export enum CodeLanguage {
   JavaScript = 'javascript',
   Python = 'python',
+  Shell = 'shell',
 }
 
 /**
@@ -22,6 +23,8 @@ export function getLanguageDisplayName(language: CodeLanguage): string {
       return 'JavaScript'
     case CodeLanguage.Python:
       return 'Python'
+    case CodeLanguage.Shell:
+      return 'Shell'
     default:
       return language
   }
diff --git a/apps/sim/lib/knowledge/connectors/sync-engine.ts b/apps/sim/lib/knowledge/connectors/sync-engine.ts
index 24ab9210f5e..e2551d5b035 100644
--- a/apps/sim/lib/knowledge/connectors/sync-engine.ts
+++ b/apps/sim/lib/knowledge/connectors/sync-engine.ts
@@ -9,10 +9,8 @@ import {
 import { createLogger } from '@sim/logger'
 import { and, eq, gt, inArray, isNull, lt, ne, or, sql } from 'drizzle-orm'
 import { decryptApiKey } from '@/lib/api-key/crypto'
-import { createBullMQJobData, isBullMQEnabled } from '@/lib/core/bullmq'
 import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
 import { generateId } from '@/lib/core/utils/uuid'
-import { enqueueWorkspaceDispatch } from '@/lib/core/workspace-dispatch'
 import type { DocumentData } from '@/lib/knowledge/documents/service'
 import {
   hardDeleteDocuments,
@@ -180,38 +178,6 @@ export async function dispatchSync(
       { tags }
     )
     logger.info(`Dispatched connector sync to Trigger.dev`, { connectorId, requestId })
-  } else if (isBullMQEnabled()) {
-    const connectorRows = await db
-      .select({
-        workspaceId: knowledgeBase.workspaceId,
-        userId: knowledgeBase.userId,
-      })
-      .from(knowledgeConnector)
-      .innerJoin(knowledgeBase, eq(knowledgeBase.id, knowledgeConnector.knowledgeBaseId))
-      .where(eq(knowledgeConnector.id, connectorId))
-      .limit(1)
-
-    const workspaceId = connectorRows[0]?.workspaceId
-    const userId = connectorRows[0]?.userId
-    if (!workspaceId || !userId) {
-      throw new Error(`No workspace found for connector ${connectorId}`)
-    }
-
-    await enqueueWorkspaceDispatch({
-      workspaceId,
-      lane: 'knowledge',
-      queueName: 'knowledge-connector-sync',
-      bullmqJobName: 'knowledge-connector-sync',
-      bullmqPayload: createBullMQJobData({
-        connectorId,
-        fullSync: options?.fullSync,
-        requestId,
-      }),
-      metadata: {
-        userId,
-      },
-    })
-    logger.info(`Dispatched connector sync to BullMQ`, { connectorId, requestId })
   } else {
     executeSync(connectorId, { fullSync: options?.fullSync }).catch((error) => {
       logger.error(`Sync failed for connector ${connectorId}`, {
diff --git a/apps/sim/lib/knowledge/documents/service.ts b/apps/sim/lib/knowledge/documents/service.ts
index c37aa22a53d..92f9318a466 100644
--- a/apps/sim/lib/knowledge/documents/service.ts
+++ b/apps/sim/lib/knowledge/documents/service.ts
@@ -28,11 +28,9 @@ import {
 import { recordUsage } from '@/lib/billing/core/usage-log'
 import { checkAndBillOverageThreshold } from '@/lib/billing/threshold-billing'
 import type { ChunkingStrategy, StrategyOptions } from '@/lib/chunkers/types'
-import { createBullMQJobData, isBullMQEnabled } from '@/lib/core/bullmq'
 import { env } from '@/lib/core/config/env'
 import { getCostMultiplier, isTriggerDevEnabled } from '@/lib/core/config/feature-flags'
 import { generateId } from '@/lib/core/utils/uuid'
-import { enqueueWorkspaceDispatch } from '@/lib/core/workspace-dispatch'
 import { processDocument } from '@/lib/knowledge/documents/document-processor'
 import type { DocumentSortField, SortOrder } from '@/lib/knowledge/documents/types'
 import { generateEmbeddings } from '@/lib/knowledge/embeddings'
@@ -82,15 +80,8 @@ const PROCESSING_CONFIG = {
   delayBetweenDocuments: (env.KB_CONFIG_DELAY_BETWEEN_DOCUMENTS || 50) * 2,
 }
 
-const REDIS_PROCESSING_CONFIG = {
-  maxConcurrentDocuments: env.KB_CONFIG_CONCURRENCY_LIMIT || 20,
-  batchSize: env.KB_CONFIG_BATCH_SIZE || 20,
-  delayBetweenBatches: env.KB_CONFIG_DELAY_BETWEEN_BATCHES || 100,
-  delayBetweenDocuments: env.KB_CONFIG_DELAY_BETWEEN_DOCUMENTS || 50,
-}
-
 export function getProcessingConfig() {
-  return isBullMQEnabled() ? REDIS_PROCESSING_CONFIG : PROCESSING_CONFIG
+  return PROCESSING_CONFIG
 }
 
 export interface DocumentData {
@@ -127,35 +118,6 @@ export async function dispatchDocumentProcessingJob(payload: DocumentJobData): P
     return
   }
 
-  if (isBullMQEnabled()) {
-    const workspaceRows = await db
-      .select({
-        workspaceId: knowledgeBase.workspaceId,
-        userId: knowledgeBase.userId,
-      })
-      .from(knowledgeBase)
-      .where(and(eq(knowledgeBase.id, payload.knowledgeBaseId), isNull(knowledgeBase.deletedAt)))
-      .limit(1)
-
-    const workspaceId = workspaceRows[0]?.workspaceId
-    const userId = workspaceRows[0]?.userId
-    if (!workspaceId || !userId) {
-      throw new Error(`Knowledge base not found: ${payload.knowledgeBaseId}`)
-    }
-
-    await enqueueWorkspaceDispatch({
-      workspaceId,
-      lane: 'knowledge',
-      queueName: 'knowledge-process-document',
-      bullmqJobName: 'knowledge-process-document',
-      bullmqPayload: createBullMQJobData(payload),
-      metadata: {
-        userId,
-      },
-    })
-    return
-  }
-
   await processDocumentAsync(
     payload.knowledgeBaseId,
     payload.documentId,
@@ -369,7 +331,7 @@ export async function processDocumentsWithQueue(
   logger.info(
     `[${requestId}] Dispatching background processing for ${jobPayloads.length} documents`,
     {
-      backend: isTriggerAvailable() ? 'trigger-dev' : isBullMQEnabled() ? 'bullmq' : 'direct',
+      backend: isTriggerAvailable() ? 'trigger-dev' : 'direct',
     }
   )
 
diff --git a/apps/sim/lib/logs/events.ts b/apps/sim/lib/logs/events.ts
index b08b7dc1313..c1f54d64da3 100644
--- a/apps/sim/lib/logs/events.ts
+++ b/apps/sim/lib/logs/events.ts
@@ -12,7 +12,6 @@ import {
 } from '@/lib/notifications/alert-rules'
 import { getActiveWorkflowContext } from '@/lib/workflows/active-context'
 import {
-  enqueueNotificationDeliveryDispatch,
   executeNotificationDelivery,
   workspaceNotificationDeliveryTask,
 } from '@/background/workspace-notification-delivery'
@@ -149,10 +148,6 @@ export async function emitWorkflowExecutionCompleted(log: WorkflowExecutionLog):
         logger.info(
           `Enqueued ${subscription.notificationType} notification ${deliveryId} via Trigger.dev`
         )
-      } else if (await enqueueNotificationDeliveryDispatch(payload)) {
-        logger.info(
-          `Enqueued ${subscription.notificationType} notification ${deliveryId} via BullMQ`
-        )
       } else {
         void executeNotificationDelivery(payload).catch((error) => {
           logger.error(`Direct notification delivery failed for ${deliveryId}`, { error })
diff --git a/apps/sim/lib/logs/service.ts b/apps/sim/lib/logs/service.ts
new file mode 100644
index 00000000000..b15b6d5b860
--- /dev/null
+++ b/apps/sim/lib/logs/service.ts
@@ -0,0 +1,31 @@
+import { db } from '@sim/db'
+import { workflow, workflowExecutionLogs } from '@sim/db/schema'
+import { eq } from 'drizzle-orm'
+
+/** Minimal log record returned by server-side service lookups. */
+export interface LogRecord {
+  id: string
+  workspaceId: string
+  startedAt: Date
+  workflowName: string | null
+}
+
+/**
+ * Fetches a log record by its primary key, joining the workflow name.
+ * Returns null if no matching record exists.
+ */
+export async function getLogById(id: string): Promise<LogRecord | null> {
+  const [record] = await db
+    .select({
+      id: workflowExecutionLogs.id,
+      workspaceId: workflowExecutionLogs.workspaceId,
+      startedAt: workflowExecutionLogs.startedAt,
+      workflowName: workflow.name,
+    })
+    .from(workflowExecutionLogs)
+    .leftJoin(workflow, eq(workflowExecutionLogs.workflowId, workflow.id))
+    .where(eq(workflowExecutionLogs.id, id))
+    .limit(1)
+
+  return record ?? null
+}
diff --git a/apps/sim/lib/mothership/inbox/executor.ts b/apps/sim/lib/mothership/inbox/executor.ts
index 1691861963d..8eaace6c3b5 100644
--- a/apps/sim/lib/mothership/inbox/executor.ts
+++ b/apps/sim/lib/mothership/inbox/executor.ts
@@ -1,14 +1,17 @@
 import { copilotChats, db, mothershipInboxTask, permissions, user, workspace } from '@sim/db'
 import { createLogger } from '@sim/logger'
 import { and, eq, sql } from 'drizzle-orm'
-import { createRunSegment } from '@/lib/copilot/async-runs/repository'
-import { resolveOrCreateChat } from '@/lib/copilot/chat-lifecycle'
-import { buildIntegrationToolSchemas } from '@/lib/copilot/chat-payload'
-import { requestChatTitle } from '@/lib/copilot/chat-streaming'
-import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
-import type { OrchestratorResult } from '@/lib/copilot/orchestrator/types'
-import { taskPubSub } from '@/lib/copilot/task-events'
-import { generateWorkspaceContext } from '@/lib/copilot/workspace-context'
+import { resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
+import { buildIntegrationToolSchemas } from '@/lib/copilot/chat/payload'
+import {
+  buildPersistedAssistantMessage,
+  buildPersistedUserMessage,
+} from '@/lib/copilot/chat/persisted-message'
+import { generateWorkspaceContext } from '@/lib/copilot/chat/workspace-context'
+import { runHeadlessCopilotLifecycle } from '@/lib/copilot/request/lifecycle/headless'
+import { requestChatTitle } from '@/lib/copilot/request/lifecycle/start'
+import type { OrchestratorResult } from '@/lib/copilot/request/types'
+import { taskPubSub } from '@/lib/copilot/tasks'
 import { isHosted } from '@/lib/core/config/feature-flags'
 import { generateId } from '@/lib/core/utils/uuid'
 import * as agentmail from '@/lib/mothership/inbox/agentmail-client'
@@ -189,27 +192,10 @@ export async function executeInboxTask(taskId: string): Promise<void> {
       ...(fileAttachments.length > 0 ? { fileAttachments } : {}),
     }
 
-    const executionId = generateId()
-    const runId = generateId()
-    const runStreamId = generateId()
-
-    if (chatId) {
-      await createRunSegment({
-        id: runId,
-        executionId,
-        chatId,
-        userId,
-        workspaceId: ws.id,
-        streamId: runStreamId,
-      }).catch(() => {})
-    }
-
-    const result = await orchestrateCopilotStream(requestPayload, {
+    const result = await runHeadlessCopilotLifecycle(requestPayload, {
       userId,
       workspaceId: ws.id,
       chatId: chatId ?? undefined,
-      executionId,
-      runId,
       goRoute: '/api/mothership/execute',
       autoExecuteTools: true,
       interactive: false,
@@ -327,23 +313,13 @@ async function persistChatMessages(
   storedAttachments: StoredAttachment[] = []
 ): Promise<void> {
   try {
-    const now = new Date().toISOString()
-
-    const userMessage = {
+    const userMessage = buildPersistedUserMessage({
       id: userMessageId,
-      role: 'user' as const,
       content: userContent,
-      timestamp: now,
-      ...(storedAttachments.length > 0 ? { fileAttachments: storedAttachments } : {}),
-    }
+      fileAttachments: storedAttachments.length > 0 ? storedAttachments : undefined,
+    })
 
-    const assistantMessage = {
-      id: generateId(),
-      role: 'assistant' as const,
-      content: result.content || '',
-      timestamp: now,
-      ...(result.error ? { errorType: 'internal' } : {}),
-    }
+    const assistantMessage = buildPersistedAssistantMessage(result)
 
     const newMessages = JSON.stringify([userMessage, assistantMessage])
     await db
diff --git a/apps/sim/lib/notifications/inactivity-polling.ts b/apps/sim/lib/notifications/inactivity-polling.ts
index 63e0e248e02..6bcd1098dee 100644
--- a/apps/sim/lib/notifications/inactivity-polling.ts
+++ b/apps/sim/lib/notifications/inactivity-polling.ts
@@ -12,7 +12,6 @@ import { isTriggerDevEnabled } from '@/lib/core/config/feature-flags'
 import { generateId } from '@/lib/core/utils/uuid'
 import { TRIGGER_TYPES } from '@/lib/workflows/triggers/triggers'
 import {
-  enqueueNotificationDeliveryDispatch,
   executeNotificationDelivery,
   workspaceNotificationDeliveryTask,
 } from '@/background/workspace-notification-delivery'
@@ -196,7 +195,6 @@ async function checkWorkflowInactivity(
         `notificationType:${subscription.notificationType}`,
       ],
     })
-  } else if (await enqueueNotificationDeliveryDispatch(payload)) {
   } else {
     void executeNotificationDelivery(payload).catch((error) => {
       logger.error(`Direct notification delivery failed for ${deliveryId}`, { error })
diff --git a/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.test.ts b/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.test.ts
new file mode 100644
index 00000000000..bd2cf91cf35
--- /dev/null
+++ b/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.test.ts
@@ -0,0 +1,51 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  findWorkspaceFileRecord,
+  normalizeWorkspaceFileReference,
+  type WorkspaceFileRecord,
+} from './workspace-file-manager'
+
+const FILE_ID = 'ec28e5d5-898a-48f0-aa6f-2fd7427c9563'
+
+function makeFileRecord(): WorkspaceFileRecord {
+  return {
+    id: FILE_ID,
+    workspaceId: 'ws_123',
+    name: 'the_last_cartographer_of_vael.md',
+    key: 'workspace/ws_123/mock-key',
+    path: '/api/files/serve/mock-key?context=workspace',
+    size: 128,
+    type: 'text/markdown',
+    uploadedBy: 'user_123',
+    uploadedAt: new Date('2026-04-13T00:00:00.000Z'),
+  }
+}
+
+describe('workspace file reference normalization', () => {
+  it('normalizes canonical by-id VFS paths to the raw file id', () => {
+    expect(normalizeWorkspaceFileReference(`files/by-id/${FILE_ID}/content`)).toBe(FILE_ID)
+    expect(normalizeWorkspaceFileReference(`files/by-id/${FILE_ID}/meta.json`)).toBe(FILE_ID)
+    expect(normalizeWorkspaceFileReference(`by-id/${FILE_ID}`)).toBe(FILE_ID)
+    expect(normalizeWorkspaceFileReference(`recently-deleted/files/by-id/${FILE_ID}/content`)).toBe(
+      FILE_ID
+    )
+  })
+
+  it('finds files from canonical by-id content paths', () => {
+    const files = [makeFileRecord()]
+
+    expect(findWorkspaceFileRecord(files, `files/by-id/${FILE_ID}/content`)).toMatchObject({
+      id: FILE_ID,
+      name: 'the_last_cartographer_of_vael.md',
+    })
+
+    expect(findWorkspaceFileRecord(files, `by-id/${FILE_ID}`)).toMatchObject({
+      id: FILE_ID,
+      name: 'the_last_cartographer_of_vael.md',
+    })
+  })
+})
diff --git a/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts b/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts
index 1c69405ffe9..6c3ea54b8b2 100644
--- a/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts
+++ b/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts
@@ -437,17 +437,29 @@ export async function listWorkspaceFiles(
  */
 export function normalizeWorkspaceFileReference(fileReference: string): string {
   const trimmed = fileReference.trim().replace(/^\/+/, '')
+  const withoutDeletedPrefix = trimmed.startsWith('recently-deleted/')
+    ? trimmed.slice('recently-deleted/'.length)
+    : trimmed
 
-  if (trimmed.startsWith('files/by-id/')) {
-    const byIdRef = trimmed.slice('files/by-id/'.length)
+  if (withoutDeletedPrefix.startsWith('files/by-id/')) {
+    const byIdRef = withoutDeletedPrefix.slice('files/by-id/'.length)
     const match = byIdRef.match(/^([^/]+)(?:\/(?:meta\.json|content))?$/)
     if (match?.[1]) {
       return match[1]
     }
   }
 
-  if (trimmed.startsWith('files/')) {
-    const withoutPrefix = trimmed.slice('files/'.length)
+  if (withoutDeletedPrefix.startsWith('by-id/')) {
+    const match = withoutDeletedPrefix
+      .slice('by-id/'.length)
+      .match(/^([^/]+)(?:\/(?:meta\.json|content))?$/)
+    if (match?.[1]) {
+      return match[1]
+    }
+  }
+
+  if (withoutDeletedPrefix.startsWith('files/')) {
+    const withoutPrefix = withoutDeletedPrefix.slice('files/'.length)
     if (withoutPrefix.endsWith('/meta.json')) {
       return withoutPrefix.slice(0, -'/meta.json'.length)
     }
@@ -457,7 +469,7 @@ export function normalizeWorkspaceFileReference(fileReference: string): string {
     return withoutPrefix
   }
 
-  return trimmed
+  return withoutDeletedPrefix
 }
 
 /**
diff --git a/apps/sim/lib/uploads/utils/file-utils.ts b/apps/sim/lib/uploads/utils/file-utils.ts
index 95dd217c297..8dc648c4e41 100644
--- a/apps/sim/lib/uploads/utils/file-utils.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.ts
@@ -204,6 +204,49 @@ const EXTENSION_TO_MIME: Record<string, string> = {
   yml: 'application/x-yaml',
   rtf: 'application/rtf',
 
+  // Code / plain-text source
+  py: 'text/x-python',
+  js: 'text/javascript',
+  mjs: 'text/javascript',
+  cjs: 'text/javascript',
+  ts: 'text/typescript',
+  tsx: 'text/typescript',
+  jsx: 'text/javascript',
+  go: 'text/x-go',
+  rs: 'text/x-rust',
+  java: 'text/x-java',
+  kt: 'text/x-kotlin',
+  c: 'text/x-c',
+  cpp: 'text/x-c++',
+  h: 'text/x-c',
+  hpp: 'text/x-c++',
+  cs: 'text/x-csharp',
+  rb: 'text/x-ruby',
+  php: 'text/x-php',
+  swift: 'text/x-swift',
+  sh: 'text/x-shellscript',
+  bash: 'text/x-shellscript',
+  zsh: 'text/x-shellscript',
+  r: 'text/x-r',
+  sql: 'text/x-sql',
+  scala: 'text/x-scala',
+  lua: 'text/x-lua',
+  pl: 'text/x-perl',
+  toml: 'text/x-toml',
+  ini: 'text/plain',
+  cfg: 'text/plain',
+  conf: 'text/plain',
+  env: 'text/plain',
+  log: 'text/plain',
+  makefile: 'text/x-makefile',
+  dockerfile: 'text/x-dockerfile',
+  css: 'text/css',
+  scss: 'text/x-scss',
+  less: 'text/x-less',
+  graphql: 'text/x-graphql',
+  gql: 'text/x-graphql',
+  proto: 'text/x-protobuf',
+
   // Audio
   mp3: 'audio/mpeg',
   m4a: 'audio/mp4',
diff --git a/apps/sim/lib/webhooks/processor.test.ts b/apps/sim/lib/webhooks/processor.test.ts
index 3f543780f71..6d644092e84 100644
--- a/apps/sim/lib/webhooks/processor.test.ts
+++ b/apps/sim/lib/webhooks/processor.test.ts
@@ -9,14 +9,12 @@ const {
   mockGenerateId,
   mockPreprocessExecution,
   mockEnqueue,
-  mockEnqueueWorkspaceDispatch,
   mockGetJobQueue,
   mockShouldExecuteInline,
 } = vi.hoisted(() => ({
   mockGenerateId: vi.fn(),
   mockPreprocessExecution: vi.fn(),
   mockEnqueue: vi.fn(),
-  mockEnqueueWorkspaceDispatch: vi.fn(),
   mockGetJobQueue: vi.fn(),
   mockShouldExecuteInline: vi.fn(),
 }))
@@ -68,15 +66,6 @@ vi.mock('@/lib/core/async-jobs', () => ({
   shouldExecuteInline: mockShouldExecuteInline,
 }))
 
-vi.mock('@/lib/core/bullmq', () => ({
-  isBullMQEnabled: vi.fn().mockReturnValue(true),
-  createBullMQJobData: vi.fn((payload: unknown, metadata?: unknown) => ({ payload, metadata })),
-}))
-
-vi.mock('@/lib/core/workspace-dispatch', () => ({
-  enqueueWorkspaceDispatch: mockEnqueueWorkspaceDispatch,
-}))
-
 vi.mock('@/lib/core/config/feature-flags', () => ({
   isProd: false,
 }))
@@ -150,7 +139,6 @@ describe('webhook processor execution identity', () => {
       actorUserId: 'actor-user-1',
     })
     mockEnqueue.mockResolvedValue('job-1')
-    mockEnqueueWorkspaceDispatch.mockResolvedValue('job-1')
     mockGetJobQueue.mockResolvedValue({ enqueue: mockEnqueue })
     mockShouldExecuteInline.mockReturnValue(false)
     mockGenerateId.mockReturnValue('generated-execution-id')
@@ -211,14 +199,16 @@ describe('webhook processor execution identity', () => {
     )
 
     expect(mockGenerateId).toHaveBeenCalledTimes(1)
-    expect(mockEnqueueWorkspaceDispatch).toHaveBeenCalledWith(
+    expect(mockEnqueue).toHaveBeenCalledWith(
+      'webhook-execution',
+      expect.objectContaining({
+        workflowId: 'workflow-1',
+        provider: 'gmail',
+      }),
       expect.objectContaining({
-        id: 'generated-execution-id',
-        workspaceId: 'workspace-1',
-        lane: 'runtime',
-        queueName: 'webhook-execution',
         metadata: expect.objectContaining({
           workflowId: 'workflow-1',
+          workspaceId: 'workspace-1',
           userId: 'actor-user-1',
           correlation: preprocessingResult.correlation,
         }),
diff --git a/apps/sim/lib/webhooks/processor.ts b/apps/sim/lib/webhooks/processor.ts
index ba20a6c4cbc..6b7aca3f20d 100644
--- a/apps/sim/lib/webhooks/processor.ts
+++ b/apps/sim/lib/webhooks/processor.ts
@@ -7,10 +7,8 @@ import { isOrganizationOnTeamOrEnterprisePlan } from '@/lib/billing/core/subscri
 import { tryAdmit } from '@/lib/core/admission/gate'
 import { getInlineJobQueue, getJobQueue, shouldExecuteInline } from '@/lib/core/async-jobs'
 import type { AsyncExecutionCorrelation } from '@/lib/core/async-jobs/types'
-import { createBullMQJobData, isBullMQEnabled } from '@/lib/core/bullmq'
 import { isProd } from '@/lib/core/config/feature-flags'
 import { generateId } from '@/lib/core/utils/uuid'
-import { DispatchQueueFullError, enqueueWorkspaceDispatch } from '@/lib/core/workspace-dispatch'
 import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
 import { preprocessExecution } from '@/lib/execution/preprocessing'
 import {
@@ -568,68 +566,32 @@ export async function queueWebhookExecution(
     const isPolling = isPollingWebhookProvider(payload.provider)
 
     if (isPolling && !shouldExecuteInline()) {
-      const jobId = isBullMQEnabled()
-        ? await enqueueWorkspaceDispatch({
-            id: executionId,
-            workspaceId: foundWorkflow.workspaceId,
-            lane: 'runtime',
-            queueName: 'webhook-execution',
-            bullmqJobName: 'webhook-execution',
-            bullmqPayload: createBullMQJobData(payload, {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            }),
-            metadata: {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            },
-          })
-        : await (await getJobQueue()).enqueue('webhook-execution', payload, {
-            metadata: {
-              workflowId: foundWorkflow.id,
-              workspaceId: foundWorkflow.workspaceId,
-              userId: actorUserId,
-              correlation,
-            },
-          })
+      const jobId = await (await getJobQueue()).enqueue('webhook-execution', payload, {
+        metadata: {
+          workflowId: foundWorkflow.id,
+          workspaceId: foundWorkflow.workspaceId,
+          userId: actorUserId,
+          correlation,
+        },
+      })
       logger.info(
         `[${options.requestId}] Queued polling webhook execution task ${jobId} for ${foundWebhook.provider} webhook via job queue`
       )
     } else {
       const jobQueue = await getInlineJobQueue()
-      const jobId = isBullMQEnabled()
-        ? await enqueueWorkspaceDispatch({
-            id: executionId,
-            workspaceId: foundWorkflow.workspaceId,
-            lane: 'runtime',
-            queueName: 'webhook-execution',
-            bullmqJobName: 'webhook-execution',
-            bullmqPayload: createBullMQJobData(payload, {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            }),
-            metadata: {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            },
-          })
-        : await jobQueue.enqueue('webhook-execution', payload, {
-            metadata: {
-              workflowId: foundWorkflow.id,
-              workspaceId: foundWorkflow.workspaceId,
-              userId: actorUserId,
-              correlation,
-            },
-          })
+      const jobId = await jobQueue.enqueue('webhook-execution', payload, {
+        metadata: {
+          workflowId: foundWorkflow.id,
+          workspaceId: foundWorkflow.workspaceId,
+          userId: actorUserId,
+          correlation,
+        },
+      })
       logger.info(
         `[${options.requestId}] Queued ${foundWebhook.provider} webhook execution ${jobId} via inline backend`
       )
 
-      if (!isBullMQEnabled()) {
+      if (shouldExecuteInline()) {
         void (async () => {
           try {
             await jobQueue.startJob(jobId)
@@ -795,66 +757,30 @@ export async function processPolledWebhookEvent(
     }
 
     if (isPollingWebhookProvider(payload.provider) && !shouldExecuteInline()) {
-      const jobId = isBullMQEnabled()
-        ? await enqueueWorkspaceDispatch({
-            id: executionId,
-            workspaceId: foundWorkflow.workspaceId,
-            lane: 'runtime',
-            queueName: 'webhook-execution',
-            bullmqJobName: 'webhook-execution',
-            bullmqPayload: createBullMQJobData(payload, {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            }),
-            metadata: {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            },
-          })
-        : await (await getJobQueue()).enqueue('webhook-execution', payload, {
-            metadata: {
-              workflowId: foundWorkflow.id,
-              workspaceId: foundWorkflow.workspaceId,
-              userId: actorUserId,
-              correlation,
-            },
-          })
+      const jobId = await (await getJobQueue()).enqueue('webhook-execution', payload, {
+        metadata: {
+          workflowId: foundWorkflow.id,
+          workspaceId: foundWorkflow.workspaceId,
+          userId: actorUserId,
+          correlation,
+        },
+      })
       logger.info(
         `[${requestId}] Queued polling webhook execution task ${jobId} for ${provider} webhook via job queue`
       )
     } else {
       const jobQueue = await getInlineJobQueue()
-      const jobId = isBullMQEnabled()
-        ? await enqueueWorkspaceDispatch({
-            id: executionId,
-            workspaceId: foundWorkflow.workspaceId,
-            lane: 'runtime',
-            queueName: 'webhook-execution',
-            bullmqJobName: 'webhook-execution',
-            bullmqPayload: createBullMQJobData(payload, {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            }),
-            metadata: {
-              workflowId: foundWorkflow.id,
-              userId: actorUserId,
-              correlation,
-            },
-          })
-        : await jobQueue.enqueue('webhook-execution', payload, {
-            metadata: {
-              workflowId: foundWorkflow.id,
-              workspaceId: foundWorkflow.workspaceId,
-              userId: actorUserId,
-              correlation,
-            },
-          })
+      const jobId = await jobQueue.enqueue('webhook-execution', payload, {
+        metadata: {
+          workflowId: foundWorkflow.id,
+          workspaceId: foundWorkflow.workspaceId,
+          userId: actorUserId,
+          correlation,
+        },
+      })
       logger.info(`[${requestId}] Queued ${provider} webhook execution ${jobId} via inline backend`)
 
-      if (!isBullMQEnabled()) {
+      if (shouldExecuteInline()) {
         void (async () => {
           try {
             await jobQueue.startJob(jobId)
@@ -884,10 +810,6 @@ export async function processPolledWebhookEvent(
 
     return { success: true }
   } catch (error: unknown) {
-    if (error instanceof DispatchQueueFullError) {
-      logger.warn(`[${requestId}] Dispatch queue full for polled webhook: ${error.message}`)
-      return { success: false, error: 'Service temporarily at capacity', statusCode: 503 }
-    }
     logger.error(`[${requestId}] Failed to process polled webhook event:`, error)
     return { success: false, error: 'Internal server error', statusCode: 500 }
   } finally {
diff --git a/apps/sim/lib/workflows/autolayout/change-set.test.ts b/apps/sim/lib/workflows/autolayout/change-set.test.ts
index e1143498344..c3fac28aec5 100644
--- a/apps/sim/lib/workflows/autolayout/change-set.test.ts
+++ b/apps/sim/lib/workflows/autolayout/change-set.test.ts
@@ -1,13 +1,43 @@
 /**
  * @vitest-environment node
  */
-import { describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   getTargetedLayoutChangeSet,
   getTargetedLayoutImpact,
 } from '@/lib/workflows/autolayout/change-set'
 import type { BlockState, WorkflowState } from '@/stores/workflows/workflow/types'
 
+const { mockGetBlock } = vi.hoisted(() => ({
+  mockGetBlock: vi.fn(),
+}))
+
+vi.mock('@/blocks', () => ({
+  getBlock: mockGetBlock,
+}))
+
+const JIRA_TEST_BLOCK_CONFIG = {
+  category: 'tools',
+  subBlocks: [
+    { id: 'operation', type: 'dropdown' },
+    { id: 'domain', type: 'short-input' },
+    { id: 'credential', type: 'oauth-input', mode: 'basic' },
+    { id: 'issueKey', type: 'short-input', condition: { field: 'operation', value: 'read' } },
+    { id: 'projectId', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'summary', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'description', type: 'long-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'priority', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'labels', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'issueType', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'parentIssue', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'assignee', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'reporter', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'environment', type: 'long-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'components', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'fixVersions', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+  ],
+} as const
+
 function createBlock(
   id: string,
   overrides: Partial<BlockState> = {},
@@ -39,7 +69,44 @@ function createWorkflowState({
   }
 }
 
+function createJiraBlock(
+  id: string,
+  operation: 'read' | 'write',
+  overrides: Partial<BlockState> = {}
+): BlockState {
+  return createBlock(id, {
+    type: 'jira',
+    position: { x: 100, y: 100 },
+    height: 100,
+    layout: { measuredWidth: 250, measuredHeight: 100 },
+    subBlocks: {
+      operation: {
+        id: 'operation',
+        type: 'dropdown',
+        value: operation,
+      },
+      domain: {
+        id: 'domain',
+        type: 'short-input',
+        value: 'company.atlassian.net',
+      },
+      credential: {
+        id: 'credential',
+        type: 'oauth-input',
+        value: 'credential-1',
+      },
+    },
+    ...overrides,
+  })
+}
+
 describe('getTargetedLayoutChangeSet', () => {
+  beforeEach(() => {
+    mockGetBlock.mockImplementation((type: string) =>
+      type === 'jira' ? JIRA_TEST_BLOCK_CONFIG : undefined
+    )
+  })
+
   it('does not relayout newly added blocks that already have valid positions', () => {
     const before = createWorkflowState({
       blocks: {
@@ -77,7 +144,15 @@ describe('getTargetedLayoutChangeSet', () => {
   it('keeps subblock-only edits anchored', () => {
     const before = createWorkflowState({
       blocks: {
-        start: createBlock('start'),
+        start: createBlock('start', {
+          subBlocks: {
+            prompt: {
+              id: 'prompt',
+              type: 'long-input',
+              value: 'old value',
+            },
+          },
+        }),
       },
     })
 
@@ -98,10 +173,40 @@ describe('getTargetedLayoutChangeSet', () => {
     expect(getTargetedLayoutChangeSet({ before, after })).toEqual([])
   })
 
+  it('reopens edited blocks when an operation change increases their visible height', () => {
+    const before = createWorkflowState({
+      blocks: {
+        jira: createJiraBlock('jira', 'read'),
+      },
+    })
+
+    const after = createWorkflowState({
+      blocks: {
+        jira: createJiraBlock('jira', 'write'),
+      },
+    })
+
+    expect(getTargetedLayoutChangeSet({ before, after })).toEqual([])
+    expect(getTargetedLayoutImpact({ before, after })).toEqual({
+      layoutBlockIds: [],
+      resizedBlockIds: ['jira'],
+      shiftSourceBlockIds: [],
+    })
+  })
+
   it('does not relayout a pre-existing block legitimately placed at the origin', () => {
     const before = createWorkflowState({
       blocks: {
-        start: createBlock('start', { position: { x: 0, y: 0 } }),
+        start: createBlock('start', {
+          position: { x: 0, y: 0 },
+          subBlocks: {
+            prompt: {
+              id: 'prompt',
+              type: 'long-input',
+              value: 'old value',
+            },
+          },
+        }),
       },
     })
 
@@ -167,6 +272,7 @@ describe('getTargetedLayoutChangeSet', () => {
 
     expect(getTargetedLayoutImpact({ before, after })).toEqual({
       layoutBlockIds: ['function1'],
+      resizedBlockIds: [],
       shiftSourceBlockIds: [],
     })
   })
@@ -231,6 +337,7 @@ describe('getTargetedLayoutChangeSet', () => {
 
     expect(getTargetedLayoutImpact({ before, after })).toEqual({
       layoutBlockIds: [],
+      resizedBlockIds: [],
       shiftSourceBlockIds: ['source'],
     })
   })
@@ -279,6 +386,7 @@ describe('getTargetedLayoutChangeSet', () => {
 
     expect(getTargetedLayoutImpact({ before, after })).toEqual({
       layoutBlockIds: [],
+      resizedBlockIds: [],
       shiftSourceBlockIds: ['a-b'],
     })
   })
@@ -327,6 +435,7 @@ describe('getTargetedLayoutChangeSet', () => {
 
     expect(getTargetedLayoutImpact({ before, after })).toEqual({
       layoutBlockIds: ['inserted'],
+      resizedBlockIds: [],
       shiftSourceBlockIds: ['inserted'],
     })
   })
diff --git a/apps/sim/lib/workflows/autolayout/change-set.ts b/apps/sim/lib/workflows/autolayout/change-set.ts
index ce57517d907..ecf12598bc3 100644
--- a/apps/sim/lib/workflows/autolayout/change-set.ts
+++ b/apps/sim/lib/workflows/autolayout/change-set.ts
@@ -1,4 +1,5 @@
 import type { Edge } from 'reactflow'
+import { getBlockMetrics } from '@/lib/workflows/autolayout/utils'
 import type { WorkflowState } from '@/stores/workflows/workflow/types'
 
 interface TargetedLayoutChangeSetOptions {
@@ -8,18 +9,21 @@ interface TargetedLayoutChangeSetOptions {
 
 export interface TargetedLayoutImpact {
   layoutBlockIds: string[]
+  resizedBlockIds: string[]
   shiftSourceBlockIds: string[]
 }
 
 /**
- * Computes the minimal structural change set that should be reopened for
- * targeted layout after a workflow edit.
+ * Computes the minimal change set that should be reopened for targeted layout
+ * after a workflow edit. `layoutBlockIds` are fully repositioned, while
+ * `resizedBlockIds` keep their existing position and only shift neighbors.
  */
 export function getTargetedLayoutImpact({
   before,
   after,
 }: TargetedLayoutChangeSetOptions): TargetedLayoutImpact {
   const layoutBlockIds = new Set<string>()
+  const resizedBlockIds = new Set<string>()
   const afterBlockIds = new Set(Object.keys(after.blocks || {}))
   const beforeBlockIds = new Set(Object.keys(before.blocks || {}))
 
@@ -40,6 +44,9 @@ export function getTargetedLayoutImpact({
     const previousParentId = before.blocks[blockId]?.data?.parentId ?? null
     const currentParentId = after.blocks[blockId]?.data?.parentId ?? null
     if (previousParentId === currentParentId) {
+      if (hasLayoutRelevantSizeChange(before.blocks[blockId], after.blocks[blockId])) {
+        resizedBlockIds.add(blockId)
+      }
       continue
     }
 
@@ -57,6 +64,7 @@ export function getTargetedLayoutImpact({
   if (addedEdges.length === 0) {
     return {
       layoutBlockIds: Array.from(layoutBlockIds),
+      resizedBlockIds: Array.from(resizedBlockIds),
       shiftSourceBlockIds: [],
     }
   }
@@ -94,6 +102,7 @@ export function getTargetedLayoutImpact({
 
   return {
     layoutBlockIds: Array.from(layoutBlockIds),
+    resizedBlockIds: Array.from(resizedBlockIds),
     shiftSourceBlockIds: Array.from(shiftSourceBlockIds),
   }
 }
@@ -123,6 +132,24 @@ function getBlocksWithInvalidPositions(
   })
 }
 
+/**
+ * Returns true when a persisted block changed size enough that anchored layout
+ * should reopen its column and shift affected siblings.
+ */
+function hasLayoutRelevantSizeChange(
+  beforeBlock: WorkflowState['blocks'][string] | undefined,
+  afterBlock: WorkflowState['blocks'][string] | undefined
+): boolean {
+  if (!beforeBlock || !afterBlock) {
+    return false
+  }
+
+  const beforeMetrics = getBlockMetrics(beforeBlock)
+  const afterMetrics = getBlockMetrics(afterBlock)
+
+  return beforeMetrics.height !== afterMetrics.height || beforeMetrics.width !== afterMetrics.width
+}
+
 /**
  * Returns added edges that participate in layout within a shared parent scope.
  */
diff --git a/apps/sim/lib/workflows/autolayout/targeted.test.ts b/apps/sim/lib/workflows/autolayout/targeted.test.ts
index 7b7fdc4efd4..117a07e7034 100644
--- a/apps/sim/lib/workflows/autolayout/targeted.test.ts
+++ b/apps/sim/lib/workflows/autolayout/targeted.test.ts
@@ -1,12 +1,43 @@
 /**
  * @vitest-environment node
  */
-import { describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { DEFAULT_VERTICAL_SPACING } from '@/lib/workflows/autolayout/constants'
 import { applyTargetedLayout } from '@/lib/workflows/autolayout/targeted'
 import type { Edge } from '@/lib/workflows/autolayout/types'
 import { getBlockMetrics } from '@/lib/workflows/autolayout/utils'
 import type { BlockState } from '@/stores/workflows/workflow/types'
 
+const { mockGetBlock } = vi.hoisted(() => ({
+  mockGetBlock: vi.fn(),
+}))
+
+vi.mock('@/blocks', () => ({
+  getBlock: mockGetBlock,
+}))
+
+const JIRA_TEST_BLOCK_CONFIG = {
+  category: 'tools',
+  subBlocks: [
+    { id: 'operation', type: 'dropdown' },
+    { id: 'domain', type: 'short-input' },
+    { id: 'credential', type: 'oauth-input', mode: 'basic' },
+    { id: 'issueKey', type: 'short-input', condition: { field: 'operation', value: 'read' } },
+    { id: 'projectId', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'summary', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'description', type: 'long-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'priority', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'labels', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'issueType', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'parentIssue', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'assignee', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'reporter', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'environment', type: 'long-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'components', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+    { id: 'fixVersions', type: 'short-input', condition: { field: 'operation', value: 'write' } },
+  ],
+} as const
+
 function createBlock(id: string, overrides: Partial<BlockState> = {}): BlockState {
   return {
     id,
@@ -20,7 +51,51 @@ function createBlock(id: string, overrides: Partial<BlockState> = {}): BlockStat
   }
 }
 
+function expectVerticalSeparation(upper: BlockState, lower: BlockState): void {
+  const upperMetrics = getBlockMetrics(upper)
+  expect(lower.position.y).toBeGreaterThanOrEqual(
+    upper.position.y + upperMetrics.height + DEFAULT_VERTICAL_SPACING
+  )
+}
+
+function createJiraBlock(
+  id: string,
+  operation: 'read' | 'write',
+  overrides: Partial<BlockState> = {}
+): BlockState {
+  return createBlock(id, {
+    type: 'jira',
+    position: { x: 100, y: 100 },
+    height: 100,
+    layout: { measuredWidth: 250, measuredHeight: 100 },
+    subBlocks: {
+      operation: {
+        id: 'operation',
+        type: 'dropdown',
+        value: operation,
+      },
+      domain: {
+        id: 'domain',
+        type: 'short-input',
+        value: 'company.atlassian.net',
+      },
+      credential: {
+        id: 'credential',
+        type: 'oauth-input',
+        value: 'credential-1',
+      },
+    },
+    ...overrides,
+  })
+}
+
 describe('applyTargetedLayout', () => {
+  beforeEach(() => {
+    mockGetBlock.mockImplementation((type: string) =>
+      type === 'jira' ? JIRA_TEST_BLOCK_CONFIG : undefined
+    )
+  })
+
   it('shifts downstream frozen blocks when only shift sources are provided', () => {
     const blocks = {
       source: createBlock('source', {
@@ -118,6 +193,128 @@ describe('applyTargetedLayout', () => {
     expect(result.changed.position.y).toBeLessThan(150)
   })
 
+  it('pushes frozen blocks below downstream nodes shifted into occupied columns', () => {
+    const blocks = {
+      start: createBlock('start', {
+        position: { x: 100, y: 100 },
+      }),
+      inserted: createBlock('inserted', {
+        position: { x: 0, y: 0 },
+      }),
+      end: createBlock('end', {
+        position: { x: 400, y: 100 },
+      }),
+      branch: createBlock('branch', {
+        position: { x: 990, y: 150 },
+      }),
+    }
+    const edges: Edge[] = [
+      {
+        id: 'edge-1',
+        source: 'start',
+        target: 'inserted',
+      },
+      {
+        id: 'edge-2',
+        source: 'inserted',
+        target: 'end',
+      },
+    ]
+
+    const result = applyTargetedLayout(blocks, edges, {
+      changedBlockIds: ['inserted'],
+    })
+
+    expect(result.end.position).toEqual({ x: 960, y: 100 })
+    expectVerticalSeparation(result.end, result.branch)
+  })
+
+  it('repairs vertical overlaps during shift-only targeted layout passes', () => {
+    const blocks = {
+      source: createBlock('source', {
+        position: { x: 100, y: 100 },
+      }),
+      target: createBlock('target', {
+        position: { x: 400, y: 100 },
+      }),
+      sibling: createBlock('sibling', {
+        position: { x: 560, y: 150 },
+      }),
+    }
+    const edges: Edge[] = [
+      {
+        id: 'edge-1',
+        source: 'source',
+        target: 'target',
+      },
+    ]
+
+    const result = applyTargetedLayout(blocks, edges, {
+      changedBlockIds: [],
+      shiftSourceBlockIds: ['source'],
+    })
+
+    expect(result.target.position).toEqual({ x: 530, y: 100 })
+    expectVerticalSeparation(result.target, result.sibling)
+  })
+
+  it('resolves same-column overlaps even when another column is interleaved in Y order', () => {
+    const blocks = {
+      source: createBlock('source', {
+        position: { x: 100, y: 100 },
+      }),
+      target: createBlock('target', {
+        position: { x: 400, y: 100 },
+      }),
+      blocker: createBlock('blocker', {
+        position: { x: 1500, y: 140 },
+      }),
+      sibling: createBlock('sibling', {
+        position: { x: 560, y: 160 },
+      }),
+    }
+    const edges: Edge[] = [
+      {
+        id: 'edge-1',
+        source: 'source',
+        target: 'target',
+      },
+    ]
+
+    const result = applyTargetedLayout(blocks, edges, {
+      changedBlockIds: [],
+      shiftSourceBlockIds: ['source'],
+    })
+
+    expect(result.blocker.position).toEqual({ x: 1500, y: 140 })
+    expect(result.target.position).toEqual({ x: 530, y: 100 })
+    expectVerticalSeparation(result.target, result.sibling)
+  })
+
+  it('keeps resized integration blocks anchored while shifting frozen blocks below them', () => {
+    const blocks = {
+      above: createBlock('above', {
+        position: { x: 430, y: 460 },
+      }),
+      jira: createJiraBlock('jira', 'write', {
+        position: { x: 433, y: 690 },
+      }),
+      below: createBlock('below', {
+        position: { x: 460, y: 1120 },
+      }),
+    }
+
+    const result = applyTargetedLayout(blocks, [], {
+      changedBlockIds: [],
+      resizedBlockIds: ['jira'],
+    })
+
+    expect(result.above.position).toEqual({ x: 430, y: 460 })
+    expect(result.jira.position).toEqual({ x: 433, y: 690 })
+    expect(getBlockMetrics(result.jira).height).toBeGreaterThan(100)
+    expectVerticalSeparation(result.jira, result.below)
+  })
+
   it('places new parallel children below tall anchored siblings', () => {
     const blocks = {
       parallel: createBlock('parallel', {
diff --git a/apps/sim/lib/workflows/autolayout/targeted.ts b/apps/sim/lib/workflows/autolayout/targeted.ts
index f7d9e64306d..33c0fb3f345 100644
--- a/apps/sim/lib/workflows/autolayout/targeted.ts
+++ b/apps/sim/lib/workflows/autolayout/targeted.ts
@@ -18,8 +18,16 @@ import {
 import { CONTAINER_DIMENSIONS } from '@/lib/workflows/blocks/block-dimensions'
 import type { BlockState } from '@/stores/workflows/workflow/types'
 
+type TargetedBlockInfo = {
+  id: string
+  block: BlockState
+  metrics: ReturnType<typeof getBlockMetrics>
+}
+
 export interface TargetedLayoutOptions extends LayoutOptions {
   changedBlockIds: string[]
+  /** Existing blocks whose size changed but whose position should remain anchored. */
+  resizedBlockIds?: string[]
   shiftSourceBlockIds?: string[]
   verticalSpacing?: number
   horizontalSpacing?: number
@@ -36,17 +44,23 @@ export function applyTargetedLayout(
 ): Record<string, BlockState> {
   const {
     changedBlockIds,
+    resizedBlockIds = [],
     shiftSourceBlockIds = [],
     verticalSpacing = DEFAULT_VERTICAL_SPACING,
     horizontalSpacing = DEFAULT_HORIZONTAL_SPACING,
     gridSize,
   } = options
 
-  if ((!changedBlockIds || changedBlockIds.length === 0) && shiftSourceBlockIds.length === 0) {
+  if (
+    (!changedBlockIds || changedBlockIds.length === 0) &&
+    resizedBlockIds.length === 0 &&
+    shiftSourceBlockIds.length === 0
+  ) {
     return blocks
   }
 
   const changedSet = new Set(changedBlockIds)
+  const resizedSet = new Set(resizedBlockIds)
   const shiftSourceSet = new Set(shiftSourceBlockIds)
   const blocksCopy: Record<string, BlockState> = JSON.parse(JSON.stringify(blocks))
 
@@ -69,6 +83,7 @@ export function applyTargetedLayout(
     blocksCopy,
     edges,
     changedSet,
+    resizedSet,
     shiftSourceSet,
     verticalSpacing,
     horizontalSpacing,
@@ -83,6 +98,7 @@ export function applyTargetedLayout(
       blocksCopy,
       edges,
       changedSet,
+      resizedSet,
       shiftSourceSet,
       verticalSpacing,
       horizontalSpacing,
@@ -130,8 +146,9 @@ function selectBestAnchor(
 
 /**
  * Layouts a group of blocks (either root level or within a container).
- * Only repositions blocks in `changedSet` or those with invalid positions;
- * all other blocks act as anchors.
+ * Only repositions blocks in `changedSet` or those with invalid positions.
+ * Resized existing blocks remain anchored and instead drive shifts in nearby
+ * frozen blocks when their new dimensions create overlap.
  */
 function layoutGroup(
   parentId: string | null,
@@ -139,6 +156,7 @@ function layoutGroup(
   blocks: Record<string, BlockState>,
   edges: Edge[],
   changedSet: Set<string>,
+  resizedSet: Set<string>,
   shiftSourceSet: Set<string>,
   verticalSpacing: number,
   horizontalSpacing: number,
@@ -170,8 +188,13 @@ function layoutGroup(
   })
   const needsLayoutSet = new Set([...requestedLayout, ...invalidPositions])
   const needsLayout = Array.from(needsLayoutSet)
+  const resizedAnchorIds = layoutEligibleChildIds.filter((id) => resizedSet.has(id))
   const groupShiftSourceIds = layoutEligibleChildIds.filter((id) => shiftSourceSet.has(id))
-  const activeShiftSourceSet = new Set([...needsLayoutSet, ...groupShiftSourceIds])
+  const activeShiftSourceSet = new Set([
+    ...needsLayoutSet,
+    ...resizedAnchorIds,
+    ...groupShiftSourceIds,
+  ])
 
   if (needsLayout.length === 0 && activeShiftSourceSet.size === 0) {
     if (parentBlock) {
@@ -236,7 +259,7 @@ function layoutGroup(
     }
   }
 
-  shiftDownstreamFrozenBlocks(
+  const shiftedFrozenIds = shiftDownstreamFrozenBlocks(
     activeShiftSourceSet,
     needsLayoutSet,
     layoutEligibleChildIds,
@@ -246,9 +269,10 @@ function layoutGroup(
     gridSize
   )
 
-  if (needsLayout.length > 0) {
+  const affectedBlockIds = new Set([...needsLayoutSet, ...resizedAnchorIds, ...shiftedFrozenIds])
+  if (affectedBlockIds.size > 0) {
     resolveVerticalOverlapsWithFrozen(
-      needsLayoutSet,
+      affectedBlockIds,
       layoutEligibleChildIds,
       blocks,
       verticalSpacing,
@@ -277,7 +301,7 @@ function shiftDownstreamFrozenBlocks(
   edges: Edge[],
   horizontalSpacing: number,
   gridSize?: number
-): void {
+): Set<string> {
   const eligibleSet = new Set(eligibleIds)
 
   const downstreamMap = new Map<string, string[]>()
@@ -317,6 +341,8 @@ function shiftDownstreamFrozenBlocks(
       }
     }
   }
+
+  return shifted
 }
 
 /**
@@ -327,7 +353,7 @@ function shiftDownstreamFrozenBlocks(
  * through any further blocks below.
  */
 function resolveVerticalOverlapsWithFrozen(
-  needsLayoutSet: Set<string>,
+  affectedBlockIds: Set<string>,
   eligibleIds: string[],
   blocks: Record<string, BlockState>,
   verticalSpacing: number,
@@ -339,11 +365,11 @@ function resolveVerticalOverlapsWithFrozen(
       if (!block) return null
       return { id, block, metrics: getBlockMetrics(block) }
     })
-    .filter((info): info is NonNullable<typeof info> => info !== null)
+    .filter((info): info is TargetedBlockInfo => info !== null)
 
-  if (blockInfos.length < 2) return
+  if (blockInfos.length < 2 || affectedBlockIds.size === 0) return
 
-  const movedSet = new Set(needsLayoutSet)
+  const movedSet = new Set(affectedBlockIds)
   let hasOverlap = true
   let iteration = 0
 
@@ -355,27 +381,48 @@ function resolveVerticalOverlapsWithFrozen(
 
     for (let i = 0; i < blockInfos.length - 1; i++) {
       const upper = blockInfos[i]
-      const lower = blockInfos[i + 1]
 
-      if (!movedSet.has(upper.id) && !movedSet.has(lower.id)) continue
+      for (let lowerIndex = i + 1; lowerIndex < blockInfos.length; lowerIndex++) {
+        const lower = blockInfos[lowerIndex]
+
+        if (!movedSet.has(upper.id) && !movedSet.has(lower.id)) continue
+        if (!blocksOverlapOnX(upper, lower)) continue
 
-      const upperRight = upper.block.position.x + upper.metrics.width
-      const lowerRight = lower.block.position.x + lower.metrics.width
-      if (upper.block.position.x >= lowerRight || lower.block.position.x >= upperRight) continue
+        const requiredY = upper.block.position.y + upper.metrics.height + verticalSpacing
+        if (lower.block.position.y >= requiredY) continue
 
-      const requiredY = upper.block.position.y + upper.metrics.height + verticalSpacing
-      if (lower.block.position.y < requiredY) {
         lower.block.position = snapPositionToGrid(
           { x: lower.block.position.x, y: requiredY },
           gridSize
         )
         movedSet.add(lower.id)
+        reorderBlockInfoByY(blockInfos, lowerIndex)
         hasOverlap = true
       }
     }
   }
 }
 
+function blocksOverlapOnX(left: TargetedBlockInfo, right: TargetedBlockInfo): boolean {
+  const leftRight = left.block.position.x + left.metrics.width
+  const rightRight = right.block.position.x + right.metrics.width
+  return left.block.position.x < rightRight && right.block.position.x < leftRight
+}
+
+function reorderBlockInfoByY(blockInfos: TargetedBlockInfo[], fromIndex: number): void {
+  const [movedInfo] = blockInfos.splice(fromIndex, 1)
+  let insertIndex = fromIndex
+
+  while (
+    insertIndex < blockInfos.length &&
+    blockInfos[insertIndex].block.position.y < movedInfo.block.position.y
+  ) {
+    insertIndex++
+  }
+
+  blockInfos.splice(insertIndex, 0, movedInfo)
+}
+
 /**
  * Computes layout positions for a subset of blocks using the core layout function
  */
diff --git a/apps/sim/lib/workflows/autolayout/utils.ts b/apps/sim/lib/workflows/autolayout/utils.ts
index ce03b76df82..ab42b48c9e3 100644
--- a/apps/sim/lib/workflows/autolayout/utils.ts
+++ b/apps/sim/lib/workflows/autolayout/utils.ts
@@ -4,14 +4,23 @@ import {
   CONTAINER_PADDING,
   CONTAINER_PADDING_X,
   CONTAINER_PADDING_Y,
-  ESTIMATED_BLOCK_BOTTOM_PADDING,
-  ESTIMATED_SUBBLOCK_HEIGHT,
-  MAX_ESTIMATED_BLOCK_HEIGHT,
   ROOT_PADDING_X,
   ROOT_PADDING_Y,
 } from '@/lib/workflows/autolayout/constants'
 import type { BlockMetrics, BoundingBox, Edge, GraphNode } from '@/lib/workflows/autolayout/types'
 import { BLOCK_DIMENSIONS, CONTAINER_DIMENSIONS } from '@/lib/workflows/blocks/block-dimensions'
+import { calculateWorkflowBlockDimensions } from '@/lib/workflows/blocks/deterministic-dimensions'
+import { getConditionRows, getRouterRows } from '@/lib/workflows/dynamic-handle-topology'
+import {
+  buildCanonicalIndex,
+  buildSubBlockValues,
+  type CanonicalModeOverrides,
+  evaluateSubBlockCondition,
+  isSubBlockFeatureEnabled,
+  isSubBlockHidden,
+  isSubBlockVisibleForMode,
+} from '@/lib/workflows/subblocks/visibility'
+import { getBlock } from '@/blocks'
 import type { BlockState } from '@/stores/workflows/workflow/types'
 
 /**
@@ -134,24 +143,98 @@ function getContainerMetrics(block: BlockState): BlockMetrics {
 }
 
 /**
- * Estimates block height from subblock count when no measurement is available.
- * Only counts subblocks with non-null values to avoid over-counting conditional
- * fields (e.g. agent blocks define ~20 subblocks but only ~5 are typically visible).
- * The result is capped at MAX_ESTIMATED_BLOCK_HEIGHT to prevent massive layout gaps.
+ * Counts visible preview subblocks using the same visibility rules as the
+ * workflow block preview when no DOM measurements are available.
+ */
+function getVisiblePreviewSubBlockCount(block: BlockState): number {
+  const blockConfig = getBlock(block.type)
+  if (!blockConfig?.subBlocks?.length) {
+    return Object.values(block.subBlocks || {}).filter((subBlock) => subBlock != null).length
+  }
+
+  const rawValues = buildSubBlockValues(block.subBlocks || {})
+  const canonicalModeOverrides =
+    typeof block.data?.canonicalModes === 'object' && block.data.canonicalModes !== null
+      ? (block.data.canonicalModes as CanonicalModeOverrides)
+      : undefined
+
+  if (canonicalModeOverrides) {
+    rawValues.__canonicalModes = canonicalModeOverrides
+  }
+
+  const canonicalIndex = buildCanonicalIndex(blockConfig.subBlocks)
+  const effectiveAdvanced = Boolean(block.advancedMode)
+  const effectiveTrigger = Boolean(block.triggerMode)
+  const isPureTriggerBlock = blockConfig.triggers?.enabled && blockConfig.category === 'triggers'
+
+  return blockConfig.subBlocks.filter((subBlock) => {
+    if (subBlock.hidden || subBlock.hideFromPreview) return false
+    if (!isSubBlockFeatureEnabled(subBlock)) return false
+    if (isSubBlockHidden(subBlock)) return false
+
+    if (effectiveTrigger) {
+      const isValidTriggerSubblock = isPureTriggerBlock
+        ? subBlock.mode === 'trigger' || !subBlock.mode
+        : subBlock.mode === 'trigger'
+
+      if (!isValidTriggerSubblock) {
+        return false
+      }
+    } else if (subBlock.mode === 'trigger') {
+      return false
+    }
+
+    if (
+      !isSubBlockVisibleForMode(
+        subBlock,
+        effectiveAdvanced,
+        canonicalIndex,
+        rawValues,
+        canonicalModeOverrides
+      )
+    ) {
+      return false
+    }
+
+    if (!subBlock.condition) return true
+    return evaluateSubBlockCondition(subBlock.condition, rawValues)
+  }).length
+}
+
+/**
+ * Estimates workflow block dimensions using the same deterministic row-based
+ * formula used by the canvas block renderer.
  */
-function estimateBlockHeight(block: BlockState): number {
-  const subBlocks = block.subBlocks || {}
-  const visibleCount = Object.values(subBlocks).filter(
-    (sb) => sb && sb.value !== null && sb.value !== undefined
-  ).length
-  if (visibleCount === 0) return BLOCK_DIMENSIONS.MIN_HEIGHT
-
-  const estimated =
-    BLOCK_DIMENSIONS.HEADER_HEIGHT +
-    visibleCount * ESTIMATED_SUBBLOCK_HEIGHT +
-    ESTIMATED_BLOCK_BOTTOM_PADDING
-
-  return Math.min(Math.max(estimated, BLOCK_DIMENSIONS.MIN_HEIGHT), MAX_ESTIMATED_BLOCK_HEIGHT)
+function estimateWorkflowBlockDimensions(block: BlockState): { width: number; height: number } {
+  const blockConfig = getBlock(block.type)
+  const visibleCount = getVisiblePreviewSubBlockCount(block)
+
+  if (!blockConfig) {
+    return {
+      width: BLOCK_DIMENSIONS.FIXED_WIDTH,
+      height: Math.max(
+        BLOCK_DIMENSIONS.HEADER_HEIGHT +
+          BLOCK_DIMENSIONS.WORKFLOW_CONTENT_PADDING +
+          visibleCount * BLOCK_DIMENSIONS.WORKFLOW_ROW_HEIGHT,
+        BLOCK_DIMENSIONS.MIN_HEIGHT
+      ),
+    }
+  }
+
+  return calculateWorkflowBlockDimensions({
+    blockType: block.type,
+    category: blockConfig.category,
+    displayTriggerMode: Boolean(block.triggerMode),
+    visibleSubBlockCount: visibleCount,
+    conditionRowCount:
+      block.type === 'condition'
+        ? getConditionRows(block.id, block.subBlocks?.conditions?.value).length
+        : 0,
+    routerRowCount:
+      block.type === 'router_v2'
+        ? getRouterRows(block.id, block.subBlocks?.routes?.value).length
+        : 0,
+  })
 }
 
 /**
@@ -164,10 +247,12 @@ function getRegularBlockMetrics(block: BlockState): BlockMetrics {
   const minHeight = BLOCK_DIMENSIONS.MIN_HEIGHT
   const measuredH = block.layout?.measuredHeight ?? block.height
   const measuredW = block.layout?.measuredWidth
+  const estimatedDimensions = estimateWorkflowBlockDimensions(block)
+  const estimatedHeight = estimatedDimensions.height
 
   const hasMeasurement = typeof measuredH === 'number' && measuredH > 0
-  const height = hasMeasurement ? Math.max(measuredH, minHeight) : estimateBlockHeight(block)
-  const width = Math.max(measuredW ?? minWidth, minWidth)
+  const height = hasMeasurement ? Math.max(measuredH, estimatedHeight, minHeight) : estimatedHeight
+  const width = Math.max(measuredW ?? estimatedDimensions.width, minWidth)
 
   return {
     width,
diff --git a/apps/sim/lib/workflows/blocks/block-reference-tags.test.ts b/apps/sim/lib/workflows/blocks/block-reference-tags.test.ts
new file mode 100644
index 00000000000..790f8597ac5
--- /dev/null
+++ b/apps/sim/lib/workflows/blocks/block-reference-tags.test.ts
@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockGetBlock } = vi.hoisted(() => ({
+  mockGetBlock: vi.fn(),
+}))
+
+vi.mock('@/blocks/registry', () => ({
+  getBlock: mockGetBlock,
+  getAllBlocks: vi.fn(() => ({})),
+}))
+
+import { getBlockReferenceTags } from '@/lib/workflows/blocks/block-reference-tags'
+
+describe('getBlockReferenceTags', () => {
+  beforeEach(() => {
+    mockGetBlock.mockReset()
+    mockGetBlock.mockReturnValue({
+      outputs: {
+        content: { type: 'string' },
+        model: { type: 'string' },
+      },
+      subBlocks: [],
+    })
+  })
+
+  it('returns agent responseFormat fields instead of default outputs', () => {
+    const tags = getBlockReferenceTags({
+      block: {
+        id: 'agent-1',
+        type: 'agent',
+        name: 'Classify Email',
+        subBlocks: {
+          responseFormat: {
+            value: {
+              name: 'email_classification',
+              schema: {
+                type: 'object',
+                properties: {
+                  isImportant: { type: 'boolean' },
+                  draftReply: { type: 'string' },
+                  reason: { type: 'string' },
+                },
+                required: ['isImportant', 'draftReply', 'reason'],
+                additionalProperties: false,
+              },
+              strict: true,
+            },
+          },
+        },
+      },
+    })
+
+    expect(tags).toEqual([
+      'classifyemail.isImportant',
+      'classifyemail.draftReply',
+      'classifyemail.reason',
+    ])
+  })
+
+  it('returns variables block assignments as block tags', () => {
+    const tags = getBlockReferenceTags({
+      block: {
+        id: 'variables-1',
+        type: 'variables',
+        name: 'Workflow Vars',
+        subBlocks: {
+          variables: {
+            value: [{ variableName: 'currentDraft' }, { variableName: 'needsRevision' }],
+          },
+        },
+      },
+    })
+
+    expect(tags).toEqual(['workflowvars.currentDraft', 'workflowvars.needsRevision'])
+  })
+})
diff --git a/apps/sim/lib/workflows/blocks/block-reference-tags.ts b/apps/sim/lib/workflows/blocks/block-reference-tags.ts
new file mode 100644
index 00000000000..f48fb20a504
--- /dev/null
+++ b/apps/sim/lib/workflows/blocks/block-reference-tags.ts
@@ -0,0 +1,83 @@
+import { getEffectiveBlockOutputPaths } from '@/lib/workflows/blocks/block-outputs'
+import { hasTriggerCapability } from '@/lib/workflows/triggers/trigger-utils'
+import { TRIGGER_TYPES } from '@/lib/workflows/triggers/triggers'
+import { getBlock } from '@/blocks'
+import { normalizeName } from '@/executor/constants'
+
+interface ReferenceableBlock {
+  id: string
+  type: string
+  name?: string
+  triggerMode?: boolean
+  subBlocks?: Record<string, { value?: unknown }>
+}
+
+interface GetBlockReferenceTagsOptions {
+  block: ReferenceableBlock
+  currentBlockId?: string
+  subBlocks?: Record<string, { value?: unknown }>
+}
+
+/**
+ * Returns the exact reference tags shown in the workflow tag dropdown for a block.
+ */
+export function getBlockReferenceTags({
+  block,
+  currentBlockId,
+  subBlocks,
+}: GetBlockReferenceTagsOptions): string[] {
+  const blockName = block.name || block.type
+  const normalizedBlockName = normalizeName(blockName)
+  const mergedSubBlocks = subBlocks ?? block.subBlocks
+
+  if (block.type === 'variables') {
+    const variablesValue = mergedSubBlocks?.variables?.value
+    if (Array.isArray(variablesValue) && variablesValue.length > 0) {
+      const validAssignments = variablesValue.filter((assignment: { variableName?: string }) =>
+        assignment?.variableName?.trim()
+      )
+      if (validAssignments.length > 0) {
+        return validAssignments.map(
+          (assignment: { variableName: string }) =>
+            `${normalizedBlockName}.${assignment.variableName.trim()}`
+        )
+      }
+    }
+
+    return [normalizedBlockName]
+  }
+
+  const blockConfig = getBlock(block.type)
+  if (!blockConfig) {
+    return []
+  }
+
+  const isTriggerCapable = hasTriggerCapability(blockConfig)
+  const effectiveTriggerMode = Boolean(block.triggerMode && isTriggerCapable)
+  const outputPaths = getEffectiveBlockOutputPaths(block.type, mergedSubBlocks, {
+    triggerMode: effectiveTriggerMode,
+    preferToolOutputs: !effectiveTriggerMode,
+  })
+  const allTags = outputPaths.map((path) => `${normalizedBlockName}.${path}`)
+
+  let blockTags: string[]
+  if (block.type === 'human_in_the_loop' && block.id === currentBlockId) {
+    blockTags = allTags.filter((tag) => tag.endsWith('.url') || tag.endsWith('.resumeEndpoint'))
+  } else if (allTags.length === 0) {
+    blockTags = [normalizedBlockName]
+  } else {
+    blockTags = allTags
+  }
+
+  if (!blockTags.includes(normalizedBlockName)) {
+    blockTags = [normalizedBlockName, ...blockTags]
+  }
+
+  const shouldShowRootTag =
+    block.type === TRIGGER_TYPES.GENERIC_WEBHOOK || block.type === 'start_trigger'
+  if (!shouldShowRootTag) {
+    blockTags = blockTags.filter((tag) => tag !== normalizedBlockName)
+  }
+
+  return blockTags
+}
diff --git a/apps/sim/lib/workflows/blocks/deterministic-dimensions.ts b/apps/sim/lib/workflows/blocks/deterministic-dimensions.ts
new file mode 100644
index 00000000000..24e236f7333
--- /dev/null
+++ b/apps/sim/lib/workflows/blocks/deterministic-dimensions.ts
@@ -0,0 +1,47 @@
+import { BLOCK_DIMENSIONS } from '@/lib/workflows/blocks/block-dimensions'
+import type { BlockConfig } from '@/blocks/types'
+
+interface WorkflowBlockDimensionsInput {
+  blockType: string
+  category: BlockConfig['category']
+  displayTriggerMode: boolean
+  visibleSubBlockCount: number
+  conditionRowCount?: number
+  routerRowCount?: number
+}
+
+export function calculateWorkflowBlockDimensions({
+  blockType,
+  category,
+  displayTriggerMode,
+  visibleSubBlockCount,
+  conditionRowCount = 0,
+  routerRowCount = 0,
+}: WorkflowBlockDimensionsInput): { width: number; height: number } {
+  const shouldShowDefaultHandles =
+    category !== 'triggers' && blockType !== 'starter' && !displayTriggerMode
+  const defaultHandlesRow = shouldShowDefaultHandles ? 1 : 0
+
+  let rowsCount = 0
+  if (blockType === 'condition') {
+    rowsCount = conditionRowCount + defaultHandlesRow
+  } else if (blockType === 'router_v2') {
+    rowsCount = 1 + routerRowCount + defaultHandlesRow
+  } else {
+    rowsCount = visibleSubBlockCount + defaultHandlesRow
+  }
+
+  const hasContentBelowHeader = rowsCount > 0
+  const contentHeight = hasContentBelowHeader
+    ? BLOCK_DIMENSIONS.WORKFLOW_CONTENT_PADDING + rowsCount * BLOCK_DIMENSIONS.WORKFLOW_ROW_HEIGHT
+    : 0
+  const height = Math.max(
+    BLOCK_DIMENSIONS.HEADER_HEIGHT + contentHeight,
+    BLOCK_DIMENSIONS.MIN_HEIGHT
+  )
+
+  return {
+    width: BLOCK_DIMENSIONS.FIXED_WIDTH,
+    height,
+  }
+}
diff --git a/apps/sim/lib/workflows/diff/diff-engine.ts b/apps/sim/lib/workflows/diff/diff-engine.ts
index 5093ac865fc..6f270882c28 100644
--- a/apps/sim/lib/workflows/diff/diff-engine.ts
+++ b/apps/sim/lib/workflows/diff/diff-engine.ts
@@ -522,14 +522,18 @@ export class WorkflowDiffEngine {
       // Apply autolayout to the proposed state
       logger.info('Applying autolayout to proposed workflow state')
       try {
-        const { layoutBlockIds, shiftSourceBlockIds } = getTargetedLayoutImpact({
+        const { layoutBlockIds, resizedBlockIds, shiftSourceBlockIds } = getTargetedLayoutImpact({
           before: mergedBaseline,
           after: fullyCleanedState,
         })
 
         const totalBlocks = Object.keys(finalBlocks).length
 
-        if (layoutBlockIds.length === 0 && shiftSourceBlockIds.length === 0) {
+        if (
+          layoutBlockIds.length === 0 &&
+          resizedBlockIds.length === 0 &&
+          shiftSourceBlockIds.length === 0
+        ) {
           logger.info('No blocks need layout; skipping autolayout', {
             totalBlocks,
           })
@@ -541,6 +545,7 @@ export class WorkflowDiffEngine {
           // as applyAutoLayout but with one unified code path.
           logger.info('Using targeted layout for copilot edits', {
             blocksNeedingLayout: layoutBlockIds.length,
+            resizedAnchorBlocks: resizedBlockIds.length,
             shiftSourceBlocks: shiftSourceBlockIds.length,
             anchors: totalBlocks - layoutBlockIds.length,
             totalBlocks,
@@ -553,6 +558,7 @@ export class WorkflowDiffEngine {
 
           const layoutedBlocks = applyTargetedLayout(finalBlocks, fullyCleanedState.edges, {
             changedBlockIds: layoutBlockIds,
+            resizedBlockIds,
             shiftSourceBlockIds,
             horizontalSpacing: DEFAULT_HORIZONTAL_SPACING,
             verticalSpacing: DEFAULT_VERTICAL_SPACING,
diff --git a/apps/sim/lib/workflows/executor/execute-workflow.ts b/apps/sim/lib/workflows/executor/execute-workflow.ts
index fccded08c78..efd5091e4c4 100644
--- a/apps/sim/lib/workflows/executor/execute-workflow.ts
+++ b/apps/sim/lib/workflows/executor/execute-workflow.ts
@@ -15,6 +15,7 @@ export interface ExecuteWorkflowOptions {
   selectedOutputs?: string[]
   isSecureMode?: boolean
   workflowTriggerType?: 'api' | 'chat' | 'copilot'
+  triggerBlockId?: string
   onStream?: (streamingExec: StreamingExecution) => Promise<void>
   onBlockComplete?: (blockId: string, output: unknown) => Promise<void>
   skipLoggingComplete?: boolean
@@ -68,6 +69,7 @@ export async function executeWorkflow(
       userId: actorUserId,
       workflowUserId: workflow.userId,
       triggerType,
+      triggerBlockId: streamConfig?.triggerBlockId,
       useDraftState: streamConfig?.useDraftState ?? false,
       startTime: new Date().toISOString(),
       isClientSession: false,
diff --git a/apps/sim/lib/workflows/executor/execution-core.test.ts b/apps/sim/lib/workflows/executor/execution-core.test.ts
index 689ebe5b2d0..a0a4e3d0da5 100644
--- a/apps/sim/lib/workflows/executor/execution-core.test.ts
+++ b/apps/sim/lib/workflows/executor/execution-core.test.ts
@@ -18,6 +18,7 @@ const {
   executorExecuteMock,
   onBlockStartPersistenceMock,
   executorConstructorMock,
+  findStartBlockMock,
 } = vi.hoisted(() => ({
   loadWorkflowFromNormalizedTablesMock: vi.fn(),
   loadDeployedWorkflowStateMock: vi.fn(),
@@ -36,6 +37,7 @@ const {
   executorExecuteMock: vi.fn(),
   onBlockStartPersistenceMock: vi.fn(),
   executorConstructorMock: vi.fn(),
+  findStartBlockMock: vi.fn(),
 }))
 
 vi.mock('@sim/logger', () => ({
@@ -70,11 +72,7 @@ vi.mock('@/lib/workflows/subblocks', () => ({
 
 vi.mock('@/lib/workflows/triggers/triggers', () => ({
   TriggerUtils: {
-    findStartBlock: vi.fn().mockReturnValue({
-      blockId: 'start-block',
-      block: { type: 'start_trigger' },
-      path: ['start-block'],
-    }),
+    findStartBlock: findStartBlockMock,
   },
 }))
 
@@ -180,6 +178,11 @@ describe('executeWorkflowCore terminal finalization sequencing', () => {
     mergeSubblockStateWithValuesMock.mockImplementation((blocks) => blocks)
     serializeWorkflowMock.mockReturnValue({ loops: {}, parallels: {} })
     buildTraceSpansMock.mockReturnValue({ traceSpans: [{ id: 'span-1' }], totalDuration: 123 })
+    findStartBlockMock.mockReturnValue({
+      blockId: 'start-block',
+      block: { type: 'start_trigger' },
+      path: ['start-block'],
+    })
     safeStartMock.mockResolvedValue(true)
     safeCompleteMock.mockResolvedValue(undefined)
     safeCompleteWithErrorMock.mockResolvedValue(undefined)
@@ -221,6 +224,30 @@ describe('executeWorkflowCore terminal finalization sequencing', () => {
     )
   })
 
+  it('uses external trigger selection for webhook executions without an explicit triggerBlockId', async () => {
+    executorExecuteMock.mockResolvedValue({
+      success: true,
+      status: 'completed',
+      output: { done: true },
+      logs: [],
+      metadata: { duration: 123, startTime: 'start', endTime: 'end' },
+    })
+
+    await executeWorkflowCore({
+      snapshot: {
+        ...createSnapshot(),
+        metadata: {
+          ...createSnapshot().metadata,
+          triggerType: 'webhook',
+        },
+      } as any,
+      callbacks: {},
+      loggingSession: loggingSession as any,
+    })
+
+    expect(findStartBlockMock).toHaveBeenCalledWith(expect.anything(), 'external', false)
+  })
+
   it('does not await user block start callback after persistence completes', async () => {
     let releaseCallback: (() => void) | undefined
     const callbackPromise = new Promise<void>((resolve) => {
diff --git a/apps/sim/lib/workflows/executor/execution-core.ts b/apps/sim/lib/workflows/executor/execution-core.ts
index b5b352d701f..d115b17486d 100644
--- a/apps/sim/lib/workflows/executor/execution-core.ts
+++ b/apps/sim/lib/workflows/executor/execution-core.ts
@@ -369,7 +369,11 @@ export async function executeWorkflowCore(
       })
     } else if (!triggerBlockId) {
       const executionKind =
-        triggerType === 'api' || triggerType === 'chat' ? (triggerType as 'api' | 'chat') : 'manual'
+        triggerType === 'api' || triggerType === 'chat'
+          ? (triggerType as 'api' | 'chat')
+          : triggerType === 'webhook' || triggerType === 'schedule'
+            ? 'external'
+            : 'manual'
 
       const startBlock = TriggerUtils.findStartBlock(mergedStates, executionKind, false)
 
diff --git a/apps/sim/lib/workflows/orchestration/chat-deploy.ts b/apps/sim/lib/workflows/orchestration/chat-deploy.ts
index ada57d50641..03ec584547d 100644
--- a/apps/sim/lib/workflows/orchestration/chat-deploy.ts
+++ b/apps/sim/lib/workflows/orchestration/chat-deploy.ts
@@ -28,6 +28,8 @@ export interface PerformChatDeployResult {
   success: boolean
   chatId?: string
   chatUrl?: string
+  deployedAt?: Date | null
+  version?: number
   error?: string
 }
 
@@ -170,7 +172,13 @@ export async function performChatDeploy(
     },
   })
 
-  return { success: true, chatId, chatUrl }
+  return {
+    success: true,
+    chatId,
+    chatUrl,
+    deployedAt: deployResult.deployedAt,
+    version: deployResult.version,
+  }
 }
 
 export interface PerformChatUndeployParams {
diff --git a/apps/sim/lib/workflows/triggers/triggers.ts b/apps/sim/lib/workflows/triggers/triggers.ts
index 9af67a0390e..ab5de09c219 100644
--- a/apps/sim/lib/workflows/triggers/triggers.ts
+++ b/apps/sim/lib/workflows/triggers/triggers.ts
@@ -28,7 +28,7 @@ export enum StartBlockPath {
   EXTERNAL_TRIGGER = 'external_trigger',
 }
 
-type StartExecutionKind = 'chat' | 'manual' | 'api'
+type StartExecutionKind = 'chat' | 'manual' | 'api' | 'external'
 
 const EXECUTION_PRIORITIES: Record<StartExecutionKind, StartBlockPath[]> = {
   chat: [StartBlockPath.UNIFIED, StartBlockPath.SPLIT_CHAT, StartBlockPath.LEGACY_STARTER],
@@ -46,6 +46,7 @@ const EXECUTION_PRIORITIES: Record<StartExecutionKind, StartBlockPath[]> = {
     StartBlockPath.SPLIT_INPUT,
     StartBlockPath.LEGACY_STARTER,
   ],
+  external: [StartBlockPath.EXTERNAL_TRIGGER],
 }
 
 const CHILD_PRIORITIES: StartBlockPath[] = [
@@ -143,6 +144,10 @@ type ResolveStartOptions = {
 }
 
 function supportsExecution(path: StartBlockPath, execution: StartExecutionKind): boolean {
+  if (execution === 'external') {
+    return path === StartBlockPath.EXTERNAL_TRIGGER
+  }
+
   if (path === StartBlockPath.UNIFIED || path === StartBlockPath.LEGACY_STARTER) {
     return true
   }
@@ -403,7 +408,7 @@ export class TriggerUtils {
    */
   static findStartBlock<T extends { type: string; subBlocks?: any }>(
     blocks: Record<string, T>,
-    executionType: 'chat' | 'manual' | 'api',
+    executionType: 'chat' | 'manual' | 'api' | 'external',
     isChildWorkflow = false
   ): (StartBlockCandidate<T> & { block: T }) | null {
     const candidates = resolveStartCandidates(blocks, {
diff --git a/apps/sim/lib/workflows/utils.ts b/apps/sim/lib/workflows/utils.ts
index 36496fd4cfa..8983b5406bf 100644
--- a/apps/sim/lib/workflows/utils.ts
+++ b/apps/sim/lib/workflows/utils.ts
@@ -655,6 +655,6 @@ export async function listFolders(workspaceId: string) {
       sortOrder: workflowFolder.sortOrder,
     })
     .from(workflowFolder)
-    .where(eq(workflowFolder.workspaceId, workspaceId))
+    .where(and(eq(workflowFolder.workspaceId, workspaceId), isNull(workflowFolder.archivedAt)))
     .orderBy(asc(workflowFolder.sortOrder), asc(workflowFolder.createdAt))
 }
diff --git a/apps/sim/next.config.ts b/apps/sim/next.config.ts
index e98d268c7bf..9cd085983f0 100644
--- a/apps/sim/next.config.ts
+++ b/apps/sim/next.config.ts
@@ -91,7 +91,12 @@ const nextConfig: NextConfig = {
   ],
   outputFileTracingIncludes: {
     '/api/tools/stagehand/*': ['./node_modules/ws/**/*'],
-    '/*': ['./node_modules/sharp/**/*', './node_modules/@img/**/*', './dist/pptx-worker.cjs'],
+    '/*': [
+      './node_modules/sharp/**/*',
+      './node_modules/@img/**/*',
+      './dist/pptx-worker.cjs',
+      './dist/doc-worker.cjs',
+    ],
   },
   experimental: {
     optimizeCss: true,
@@ -113,7 +118,7 @@ const nextConfig: NextConfig = {
       '@radix-ui/react-checkbox',
       '@radix-ui/react-switch',
       '@radix-ui/react-slider',
-      'react-markdown',
+      'streamdown',
       'zod',
       'date-fns',
     ],
diff --git a/apps/sim/package.json b/apps/sim/package.json
index 0a8150656fe..4e37939cb89 100644
--- a/apps/sim/package.json
+++ b/apps/sim/package.json
@@ -11,15 +11,15 @@
     "dev": "next dev --port 3000",
     "dev:webpack": "next dev --webpack",
     "dev:sockets": "bun run socket/index.ts",
-    "dev:full": "bunx concurrently -n \"App,Realtime,Worker\" -c \"cyan,magenta,yellow\" \"bun run dev\" \"bun run dev:sockets\" \"bun run worker\"",
+    "dev:full": "bunx concurrently -n \"App,Realtime\" -c \"cyan,magenta\" \"bun run dev\" \"bun run dev:sockets\"",
     "load:workflow": "bun run load:workflow:baseline",
     "load:workflow:baseline": "BASE_URL=${BASE_URL:-http://localhost:3000} WARMUP_DURATION=${WARMUP_DURATION:-10} WARMUP_RATE=${WARMUP_RATE:-2} PEAK_RATE=${PEAK_RATE:-8} HOLD_DURATION=${HOLD_DURATION:-20} bunx artillery run scripts/load/workflow-concurrency.yml",
     "load:workflow:waves": "BASE_URL=${BASE_URL:-http://localhost:3000} WAVE_ONE_DURATION=${WAVE_ONE_DURATION:-10} WAVE_ONE_RATE=${WAVE_ONE_RATE:-6} QUIET_DURATION=${QUIET_DURATION:-5} WAVE_TWO_DURATION=${WAVE_TWO_DURATION:-15} WAVE_TWO_RATE=${WAVE_TWO_RATE:-8} WAVE_THREE_DURATION=${WAVE_THREE_DURATION:-20} WAVE_THREE_RATE=${WAVE_THREE_RATE:-10} bunx artillery run scripts/load/workflow-waves.yml",
     "load:workflow:isolation": "BASE_URL=${BASE_URL:-http://localhost:3000} ISOLATION_DURATION=${ISOLATION_DURATION:-30} TOTAL_RATE=${TOTAL_RATE:-9} WORKSPACE_A_WEIGHT=${WORKSPACE_A_WEIGHT:-8} WORKSPACE_B_WEIGHT=${WORKSPACE_B_WEIGHT:-1} bunx artillery run scripts/load/workflow-isolation.yml",
-    "build": "bun run build:pptx-worker && next build",
+    "build": "bun run build:pptx-worker && bun run build:doc-worker && next build",
     "build:pptx-worker": "bun build ./lib/execution/pptx-worker.cjs --target=node --format=cjs --outfile ./dist/pptx-worker.cjs",
+    "build:doc-worker": "bun build ./lib/execution/doc-worker.cjs --target=node --format=cjs --outfile ./dist/doc-worker.cjs",
     "start": "next start",
-    "worker": "NODE_ENV=production bun run worker/index.ts",
     "prepare": "cd ../.. && bun husky",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -97,11 +97,11 @@
     "@trigger.dev/sdk": "4.4.3",
     "@types/react-window": "2.0.0",
     "@types/three": "0.177.0",
+    "ajv": "8.18.0",
     "better-auth": "1.3.12",
     "better-auth-harmony": "1.3.1",
     "binary-extensions": "^2.0.0",
     "browser-image-compression": "^2.0.2",
-    "bullmq": "5.71.0",
     "chalk": "5.6.2",
     "chart.js": "4.5.1",
     "cheerio": "1.1.2",
@@ -113,6 +113,8 @@
     "csv-parse": "6.1.0",
     "date-fns": "4.1.0",
     "decimal.js": "10.6.0",
+    "docx": "^9.6.1",
+    "docx-preview": "^0.3.7",
     "drizzle-orm": "^0.44.5",
     "encoding": "0.1.13",
     "entities": "6.0.1",
@@ -165,7 +167,6 @@
     "react-dom": "19.2.4",
     "react-hook-form": "^7.54.2",
     "react-joyride": "2.9.3",
-    "react-markdown": "^10.1.0",
     "react-simple-code-editor": "^0.14.1",
     "react-window": "2.2.3",
     "reactflow": "^11.11.4",
@@ -182,6 +183,7 @@
     "socket.io": "^4.8.1",
     "socket.io-client": "4.8.1",
     "ssh2": "^1.17.0",
+    "streamdown": "2.5.0",
     "stripe": "18.5.0",
     "svix": "1.88.0",
     "tailwind-merge": "^2.6.0",
diff --git a/apps/sim/scripts/load/README.md b/apps/sim/scripts/load/README.md
index 926f84fad57..43a08976431 100644
--- a/apps/sim/scripts/load/README.md
+++ b/apps/sim/scripts/load/README.md
@@ -11,14 +11,8 @@ These local-only Artillery scenarios exercise `POST /api/workflows/[id]/execute`
 The default rates are tuned for these local limits:
 
 - `ADMISSION_GATE_MAX_INFLIGHT=500`
-- `DISPATCH_MAX_QUEUE_PER_WORKSPACE=1000`
-- `DISPATCH_MAX_QUEUE_GLOBAL=50000`
-- `WORKSPACE_CONCURRENCY_FREE=5`
-- `WORKSPACE_CONCURRENCY_PRO=50`
-- `WORKSPACE_CONCURRENCY_TEAM=200`
-- `WORKSPACE_CONCURRENCY_ENTERPRISE=200`
 
-That means the defaults are intentionally aimed at forcing queueing for a Free workspace without overwhelming a single local dev server process.
+The admission gate caps total in-flight requests per pod.
 
 ## Baseline Concurrency
 
@@ -109,5 +103,5 @@ Optional variables:
 - `load:workflow` is an alias for `load:workflow:baseline`
 - All scenarios send `x-execution-mode: async`
 - Artillery output will show request counts and response codes, which is usually enough for quick local verification
-- At these defaults, you should observe queueing behavior before you approach `ADMISSION_GATE_MAX_INFLIGHT=500` or `DISPATCH_MAX_QUEUE_PER_WORKSPACE=1000`
+- At these defaults, you should see `429` responses when approaching `ADMISSION_GATE_MAX_INFLIGHT=500`
 - If you still see lots of `429` or `ETIMEDOUT` responses locally, lower the rates again before increasing durations
diff --git a/apps/sim/stores/panel/copilot/types.ts b/apps/sim/stores/panel/copilot/types.ts
deleted file mode 100644
index 796cc53087e..00000000000
--- a/apps/sim/stores/panel/copilot/types.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import type { ServerToolUI } from '@/lib/copilot/store-utils'
-import type {
-  ClientToolCallState,
-  ClientToolDisplay,
-} from '@/lib/copilot/tools/client/tool-display-registry'
-import type { ChatContext as PanelChatContext } from '@/stores/panel/types'
-
-export type ChatContext = PanelChatContext
-
-export interface CopilotToolCall {
-  id: string
-  name: string
-  state: ClientToolCallState
-  display?: ClientToolDisplay
-  params?: Record<string, unknown>
-  input?: Record<string, unknown>
-  serverUI?: ServerToolUI
-  clientExecutable?: boolean
-  result?: { success: boolean; output?: unknown; error?: string }
-  error?: string
-  calledBy?: string
-  streamingArgs?: string
-}
-
-export interface SubAgentContentBlock {
-  type: string
-  content?: string
-  toolCall?: CopilotToolCall | null
-}
-
-export interface CopilotStreamInfo {
-  chatId?: string
-  streamId?: string
-  messageId?: string
-}
-
-export interface CopilotStore {
-  messages: Array<Record<string, unknown>>
-  toolCallsById: Record<string, CopilotToolCall>
-  activeStream: CopilotStreamInfo | null
-  streamingPlanContent?: string
-  handleNewChatCreation: (chatId: string) => Promise<void>
-  updatePlanTodoStatus: (todoId: string, status: string) => void
-  [key: string]: unknown
-}
-
-export type { ClientToolCallState, ClientToolDisplay }
diff --git a/apps/sim/stores/panel/index.ts b/apps/sim/stores/panel/index.ts
index cf2c541411f..5ce6320df74 100644
--- a/apps/sim/stores/panel/index.ts
+++ b/apps/sim/stores/panel/index.ts
@@ -1,8 +1,6 @@
 // Main panel store
 
 export { ClientToolCallState as ToolState } from '@/lib/copilot/tools/client/tool-display-registry'
-// Copilot types
-export type { CopilotToolCall } from './copilot/types'
 // Editor
 export { usePanelEditorStore } from './editor'
 export { usePanelStore } from './store'
diff --git a/apps/sim/tools/function/execute.ts b/apps/sim/tools/function/execute.ts
index d8e75ca55d3..844b1c6d515 100644
--- a/apps/sim/tools/function/execute.ts
+++ b/apps/sim/tools/function/execute.ts
@@ -7,7 +7,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
   id: 'function_execute',
   name: 'Function Execute',
   description:
-    'Execute JavaScript code. fetch() is available. Code runs in async IIFE wrapper automatically. CRITICAL: Write plain statements with await/return, NOT wrapped in functions. Example for API call: const res = await fetch(url); const data = await res.json(); return data;',
+    'Execute JavaScript, Python, or shell scripts in a secure sandbox. For JS: fetch() is available, code runs in async IIFE wrapper. For shell: workspace env vars available as $VAR_NAME, pre-installed CLI tools (jq, curl, awscli, psql, gh, etc.). Use outputPath/outputTable to persist returned data, or outputSandboxPath + outputPath to export a file created inside the sandbox into the workspace.',
   version: '1.0.0',
 
   params: {
@@ -22,7 +22,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
       type: 'string',
       required: false,
       visibility: 'user-only',
-      description: 'Language to execute (javascript or python)',
+      description: 'Language to execute (javascript, python, or shell)',
       default: DEFAULT_CODE_LANGUAGE,
     },
     timeout: {
@@ -32,6 +32,40 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
       description: 'Execution timeout in milliseconds',
       default: DEFAULT_EXECUTION_TIMEOUT_MS,
     },
+    outputPath: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'Write the tool result back to a workspace file, e.g. "files/result.json" or "files/report.csv". Use for text/JSON/CSV/markdown/html outputs.',
+    },
+    outputFormat: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description: 'Optional format override for outputPath (json, csv, txt, md, html).',
+    },
+    outputTable: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'Overwrite a workspace table with the code result. The code must return an array of objects.',
+    },
+    outputSandboxPath: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'Export a file created inside the sandbox to the workspace. Provide the sandbox file path here and also set outputPath to the workspace destination.',
+    },
+    outputMimeType: {
+      type: 'string',
+      required: false,
+      visibility: 'hidden',
+      description:
+        'MIME type for the exported file. Required for binary files (e.g. "image/png", "application/pdf"). If omitted, inferred from outputPath extension for text formats.',
+    },
     envVars: {
       type: 'object',
       required: false,
@@ -84,6 +118,11 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
         code: codeContent,
         language: params.language || DEFAULT_CODE_LANGUAGE,
         timeout: params.timeout || DEFAULT_EXECUTION_TIMEOUT_MS,
+        outputPath: params.outputPath,
+        outputFormat: params.outputFormat,
+        outputTable: params.outputTable,
+        outputSandboxPath: params.outputSandboxPath,
+        outputMimeType: params.outputMimeType,
         envVars: params.envVars || {},
         workflowVariables: params.workflowVariables || {},
         blockData: params.blockData || {},
@@ -91,6 +130,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
         blockOutputSchemas: params.blockOutputSchemas || {},
         workflowId: params._context?.workflowId,
         userId: params._context?.userId,
+        workspaceId: params._context?.workspaceId,
         isCustomTool: params.isCustomTool || false,
       }
 
@@ -113,6 +153,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
           stdout: result.output?.stdout || '',
         },
         error: result.error,
+        resources: result.resources,
       }
     }
 
@@ -122,6 +163,7 @@ export const functionExecuteTool: ToolConfig<CodeExecutionInput, CodeExecutionOu
         result: result.output.result,
         stdout: result.output.stdout,
       },
+      resources: result.resources,
     }
   },
 
diff --git a/apps/sim/tools/function/types.ts b/apps/sim/tools/function/types.ts
index 0fea6bf7b23..9fb66875a35 100644
--- a/apps/sim/tools/function/types.ts
+++ b/apps/sim/tools/function/types.ts
@@ -7,6 +7,11 @@ export interface CodeExecutionInput {
   useLocalVM?: boolean
   timeout?: number
   memoryLimit?: number
+  outputPath?: string
+  outputFormat?: 'json' | 'csv' | 'txt' | 'md' | 'html'
+  outputTable?: string
+  outputSandboxPath?: string
+  outputMimeType?: string
   envVars?: Record<string, string>
   workflowVariables?: Record<string, unknown>
   blockData?: Record<string, unknown>
@@ -15,6 +20,7 @@ export interface CodeExecutionInput {
   _context?: {
     workflowId?: string
     userId?: string
+    workspaceId?: string
   }
   isCustomTool?: boolean
   _sandboxFiles?: Array<{ path: string; content: string }>
diff --git a/apps/sim/tools/index.test.ts b/apps/sim/tools/index.test.ts
index cef7cc82a19..ed9e0197acc 100644
--- a/apps/sim/tools/index.test.ts
+++ b/apps/sim/tools/index.test.ts
@@ -28,6 +28,7 @@ const {
   mockGenerateInternalToken,
   mockSecureFetchWithPinnedIP,
   mockValidateUrlWithDNS,
+  mockResolveWorkspaceFileReference,
 } = vi.hoisted(() => ({
   mockIsHosted: { value: false },
   mockEnv: { NEXT_PUBLIC_APP_URL: 'http://localhost:3000' } as Record<string, string | undefined>,
@@ -44,6 +45,7 @@ const {
   mockGenerateInternalToken: vi.fn(),
   mockSecureFetchWithPinnedIP: vi.fn(),
   mockValidateUrlWithDNS: vi.fn(),
+  mockResolveWorkspaceFileReference: vi.fn(),
 }))
 
 // Mock feature flags
@@ -86,6 +88,10 @@ vi.mock('@/lib/core/rate-limiter/hosted-key', () => ({
   getHostedKeyRateLimiter: () => mockRateLimiterFns,
 }))
 
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  resolveWorkspaceFileReference: (...args: unknown[]) => mockResolveWorkspaceFileReference(...args),
+}))
+
 // Mock the tools registry to avoid loading the full 4500+ line registry file.
 // Only the tools actually exercised in tests are provided.
 vi.mock('@/tools/registry', () => {
@@ -188,6 +194,44 @@ vi.mock('@/tools/registry', () => {
       params: {},
       request: { url: '/api/tools/gmail/send', method: 'POST' },
     },
+    test_single_file_tool: {
+      id: 'test_single_file_tool',
+      name: 'Test Single File Tool',
+      description: 'Accepts a single file parameter',
+      version: '1.0.0',
+      params: {
+        attachment: { type: 'file', required: true },
+      },
+      request: {
+        url: '/api/tools/test/single-file',
+        method: 'POST',
+        headers: () => ({ 'Content-Type': 'application/json' }),
+        body: (p: any) => ({ attachment: p.attachment }),
+      },
+      transformResponse: async (response: any) => {
+        const data = await response.json()
+        return { success: true, output: data }
+      },
+    },
+    test_file_array_tool: {
+      id: 'test_file_array_tool',
+      name: 'Test File Array Tool',
+      description: 'Accepts an array of file parameters',
+      version: '1.0.0',
+      params: {
+        attachments: { type: 'file[]', required: true },
+      },
+      request: {
+        url: '/api/tools/test/file-array',
+        method: 'POST',
+        headers: () => ({ 'Content-Type': 'application/json' }),
+        body: (p: any) => ({ attachments: p.attachments }),
+      },
+      transformResponse: async (response: any) => {
+        const data = await response.json()
+        return { success: true, output: data }
+      },
+    },
     google_drive_list: {
       id: 'google_drive_list',
       name: 'Google Drive List',
@@ -747,6 +791,197 @@ describe('Automatic Internal Route Detection', () => {
   })
 })
 
+describe('Copilot File Parameter Normalization', () => {
+  let cleanupEnvVars: () => void
+
+  beforeEach(() => {
+    process.env.NEXT_PUBLIC_APP_URL = 'http://localhost:3000'
+    cleanupEnvVars = setupEnvVars({ NEXT_PUBLIC_APP_URL: 'http://localhost:3000' })
+    mockResolveWorkspaceFileReference.mockReset()
+  })
+
+  afterEach(() => {
+    vi.resetAllMocks()
+    cleanupEnvVars()
+  })
+
+  it('resolves canonical file IDs for single-file params during copilot execution', async () => {
+    mockResolveWorkspaceFileReference.mockResolvedValue({
+      id: 'wf_123',
+      name: 'brief.pdf',
+      path: '/api/files/wf_123',
+      size: 512,
+      type: 'application/pdf',
+      key: 'uploads/wf_123',
+    })
+
+    global.fetch = Object.assign(
+      vi.fn().mockImplementation(async (_url, options) => {
+        const body = JSON.parse(options?.body as string)
+        expect(body.attachment).toEqual({
+          id: 'wf_123',
+          name: 'brief.pdf',
+          url: '/api/files/wf_123',
+          size: 512,
+          type: 'application/pdf',
+          key: 'uploads/wf_123',
+          context: 'workspace',
+        })
+
+        return {
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          headers: new Headers(),
+          json: () => Promise.resolve({ ok: true }),
+          text: () => Promise.resolve(JSON.stringify({ ok: true })),
+          clone: vi.fn().mockReturnThis(),
+        }
+      }),
+      { preconnect: vi.fn() }
+    ) as typeof fetch
+
+    const context = createToolExecutionContext({
+      workspaceId: 'workspace-456',
+      copilotToolExecution: true,
+    } as any)
+
+    const result = await executeTool(
+      'test_single_file_tool',
+      { attachment: 'wf_123' },
+      false,
+      context
+    )
+
+    expect(result.success).toBe(true)
+    expect(mockResolveWorkspaceFileReference).toHaveBeenCalledWith('workspace-456', 'wf_123')
+  })
+
+  it('resolves file-array params from strings and partial file objects, while preserving full file objects', async () => {
+    mockResolveWorkspaceFileReference.mockImplementation(
+      async (_workspaceId: string, fileId: string) => ({
+        id: fileId,
+        name: `${fileId}.txt`,
+        path: `/api/files/${fileId}`,
+        size: 128,
+        type: 'text/plain',
+        key: `uploads/${fileId}`,
+      })
+    )
+
+    const existingFileObject = {
+      id: 'wf_existing',
+      name: 'existing.txt',
+      url: '/api/files/wf_existing',
+      size: 64,
+      type: 'text/plain',
+      key: 'uploads/wf_existing',
+      context: 'workspace',
+    }
+
+    const partialFileObject = {
+      id: 'wf_partial',
+      name: 'partial.txt',
+    }
+
+    global.fetch = Object.assign(
+      vi.fn().mockImplementation(async (_url, options) => {
+        const body = JSON.parse(options?.body as string)
+        expect(body.attachments).toEqual([
+          {
+            id: 'wf_1',
+            name: 'wf_1.txt',
+            url: '/api/files/wf_1',
+            size: 128,
+            type: 'text/plain',
+            key: 'uploads/wf_1',
+            context: 'workspace',
+          },
+          {
+            id: 'wf_partial',
+            name: 'wf_partial.txt',
+            url: '/api/files/wf_partial',
+            size: 128,
+            type: 'text/plain',
+            key: 'uploads/wf_partial',
+            context: 'workspace',
+          },
+          existingFileObject,
+          {
+            id: 'wf_2',
+            name: 'wf_2.txt',
+            url: '/api/files/wf_2',
+            size: 128,
+            type: 'text/plain',
+            key: 'uploads/wf_2',
+            context: 'workspace',
+          },
+        ])
+
+        return {
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          headers: new Headers(),
+          json: () => Promise.resolve({ ok: true }),
+          text: () => Promise.resolve(JSON.stringify({ ok: true })),
+          clone: vi.fn().mockReturnThis(),
+        }
+      }),
+      { preconnect: vi.fn() }
+    ) as typeof fetch
+
+    const context = createToolExecutionContext({
+      workspaceId: 'workspace-456',
+      copilotToolExecution: true,
+    } as any)
+
+    const result = await executeTool(
+      'test_file_array_tool',
+      { attachments: ['wf_1', partialFileObject, existingFileObject, 'wf_2'] },
+      false,
+      context
+    )
+
+    expect(result.success).toBe(true)
+    expect(mockResolveWorkspaceFileReference).toHaveBeenCalledTimes(3)
+  })
+
+  it('does not resolve file params outside copilot execution', async () => {
+    global.fetch = Object.assign(
+      vi.fn().mockImplementation(async (_url, options) => {
+        const body = JSON.parse(options?.body as string)
+        expect(body.attachment).toBe('wf_123')
+
+        return {
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          headers: new Headers(),
+          json: () => Promise.resolve({ ok: true }),
+          text: () => Promise.resolve(JSON.stringify({ ok: true })),
+          clone: vi.fn().mockReturnThis(),
+        }
+      }),
+      { preconnect: vi.fn() }
+    ) as typeof fetch
+
+    const context = createToolExecutionContext({
+      workspaceId: 'workspace-456',
+    } as any)
+
+    const result = await executeTool(
+      'test_single_file_tool',
+      { attachment: 'wf_123' },
+      false,
+      context
+    )
+
+    expect(result.success).toBe(true)
+    expect(mockResolveWorkspaceFileReference).not.toHaveBeenCalled()
+  })
+})
+
 describe('Centralized Error Handling', () => {
   let cleanupEnvVars: () => void
 
diff --git a/apps/sim/tools/index.ts b/apps/sim/tools/index.ts
index e48e05baf2d..6062417a07b 100644
--- a/apps/sim/tools/index.ts
+++ b/apps/sim/tools/index.ts
@@ -11,11 +11,13 @@ import {
 import { PlatformEvents } from '@/lib/core/telemetry'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { getBaseUrl, getInternalApiBaseUrl } from '@/lib/core/utils/urls'
+import { isUserFile } from '@/lib/core/utils/user-file'
 import { SIM_VIA_HEADER, serializeCallChain } from '@/lib/execution/call-chain'
 import { parseMcpToolId } from '@/lib/mcp/utils'
+import { resolveWorkspaceFileReference } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 import { isCustomTool, isMcpTool } from '@/executor/constants'
 import { resolveSkillContent } from '@/executor/handlers/agent/skills-resolver'
-import type { ExecutionContext } from '@/executor/types'
+import type { ExecutionContext, UserFile } from '@/executor/types'
 import type { ErrorInfo } from '@/tools/error-extractors'
 import { extractErrorMessage } from '@/tools/error-extractors'
 import type {
@@ -39,6 +41,7 @@ interface ToolExecutionScope {
   callChain?: string[]
   isDeployedContext?: boolean
   enforceCredentialAccess?: boolean
+  copilotToolExecution?: boolean
 }
 
 function resolveToolScope(
@@ -57,6 +60,108 @@ function resolveToolScope(
       | undefined,
     enforceCredentialAccess: (executionContext?.enforceCredentialAccess ??
       ctx?.enforceCredentialAccess) as boolean | undefined,
+    copilotToolExecution: (executionContext?.copilotToolExecution ?? ctx?.copilotToolExecution) as
+      | boolean
+      | undefined,
+  }
+}
+
+function toUserFileFromWorkspaceRecord(record: {
+  id: string
+  name: string
+  path: string
+  url?: string
+  size: number
+  type: string
+  key: string
+}): UserFile {
+  return {
+    id: record.id,
+    name: record.name,
+    url: record.url ?? record.path,
+    size: record.size,
+    type: record.type,
+    key: record.key,
+    context: 'workspace',
+  }
+}
+
+async function resolveCopilotFileReference(
+  value: unknown,
+  workspaceId: string,
+  paramId: string
+): Promise<UserFile | unknown> {
+  if (isUserFile(value)) {
+    return value
+  }
+
+  const referenceId =
+    typeof value === 'string'
+      ? value
+      : value &&
+          typeof value === 'object' &&
+          typeof (value as Record<string, unknown>).id === 'string'
+        ? ((value as Record<string, unknown>).id as string)
+        : null
+
+  if (!referenceId) {
+    return value
+  }
+
+  const fileRecord = await resolveWorkspaceFileReference(workspaceId, referenceId)
+  if (!fileRecord) {
+    throw new Error(
+      `Could not resolve workspace file reference "${referenceId}" for parameter "${paramId}"`
+    )
+  }
+
+  const resolvedFile = toUserFileFromWorkspaceRecord(fileRecord)
+  if (!value || typeof value !== 'object') {
+    return resolvedFile
+  }
+
+  const candidate = value as Record<string, unknown>
+  return {
+    ...resolvedFile,
+    context: typeof candidate.context === 'string' ? candidate.context : resolvedFile.context,
+    base64: typeof candidate.base64 === 'string' ? candidate.base64 : undefined,
+  }
+}
+
+async function normalizeCopilotFileParams(
+  tool: ToolConfig,
+  params: Record<string, unknown>,
+  scope: ToolExecutionScope
+): Promise<void> {
+  if (!scope.copilotToolExecution) {
+    return
+  }
+
+  for (const [paramId, paramDef] of Object.entries(tool.params || {})) {
+    const paramType = paramDef?.type
+    const currentValue = params[paramId]
+    if (currentValue === undefined || currentValue === null) {
+      continue
+    }
+
+    if (paramType === 'file') {
+      if (!scope.workspaceId) {
+        throw new Error(`Missing workspaceId while resolving file parameter "${paramId}"`)
+      }
+      params[paramId] = await resolveCopilotFileReference(currentValue, scope.workspaceId, paramId)
+      continue
+    }
+
+    if (paramType === 'file[]') {
+      if (!scope.workspaceId) {
+        throw new Error(`Missing workspaceId while resolving file parameter "${paramId}"`)
+      }
+
+      const values = Array.isArray(currentValue) ? currentValue : [currentValue]
+      params[paramId] = await Promise.all(
+        values.map((item) => resolveCopilotFileReference(item, scope.workspaceId!, paramId))
+      )
+    }
   }
 }
 
@@ -683,6 +788,8 @@ export async function executeTool(
       throw new Error(`Tool not found: ${toolId}`)
     }
 
+    await normalizeCopilotFileParams(tool, contextParams, scope)
+
     // Inject hosted API key if tool supports it and user didn't provide one
     const hostedKeyInfo = await injectHostedKeyIfNeeded(
       tool,
@@ -695,7 +802,6 @@ export async function executeTool(
     if (contextParams.oauthCredential) {
       contextParams.credential = contextParams.oauthCredential
     }
-
     if (contextParams.credential) {
       logger.info(
         `[${requestId}] Tool ${toolId} needs access token for credential: ${contextParams.credential}`
@@ -1233,7 +1339,10 @@ async function executeToolRequest(
         if (isInternalRoute) {
           const controller = new AbortController()
           const timeout = requestParams.timeout || DEFAULT_EXECUTION_TIMEOUT_MS
-          const timeoutId = setTimeout(() => controller.abort(), timeout)
+          const timeoutId = setTimeout(
+            () => controller.abort(`timeout:internal_tool_fetch:${timeout}ms`),
+            timeout
+          )
 
           try {
             response = await fetch(fullUrl, {
diff --git a/apps/sim/tools/params.test.ts b/apps/sim/tools/params.test.ts
index fff2c780b19..8aea57cd2ec 100644
--- a/apps/sim/tools/params.test.ts
+++ b/apps/sim/tools/params.test.ts
@@ -141,6 +141,61 @@ describe('Tool Parameters Utils', () => {
       expect(schema.required).not.toContain('accessToken')
       expect(schema.properties).toHaveProperty('message')
     })
+
+    it.concurrent('keeps shared file params unchanged by default', () => {
+      const toolWithFileParam = {
+        ...mockToolConfig,
+        id: 'file_schema_tool',
+        params: {
+          attachment: {
+            type: 'file',
+            required: true,
+            visibility: 'user-or-llm' as ParameterVisibility,
+            description: 'Attachment file',
+          },
+        },
+      }
+
+      const schema = createUserToolSchema(toolWithFileParam)
+
+      expect(schema.properties.attachment).toMatchObject({
+        type: 'file',
+        description: 'Attachment file',
+      })
+    })
+
+    it.concurrent('expands file params for copilot-facing schemas', () => {
+      const toolWithFileParams = {
+        ...mockToolConfig,
+        id: 'copilot_file_schema_tool',
+        params: {
+          attachment: {
+            type: 'file',
+            required: true,
+            visibility: 'user-or-llm' as ParameterVisibility,
+            description: 'Attachment file',
+          },
+          attachments: {
+            type: 'file[]',
+            required: false,
+            visibility: 'user-or-llm' as ParameterVisibility,
+            description: 'Attachment files',
+          },
+        },
+      }
+
+      const schema = createUserToolSchema(toolWithFileParams, { surface: 'copilot' })
+
+      expect(schema.properties.attachment).toMatchObject({
+        type: 'object',
+        required: ['id', 'name', 'url', 'size', 'type', 'key'],
+      })
+      expect(schema.properties.attachment.description).toContain('canonical workspace file IDs')
+      expect(schema.properties.attachments).toMatchObject({
+        type: 'array',
+      })
+      expect(schema.properties.attachments.description).toContain('canonical workspace file IDs')
+    })
   })
 
   describe('createExecutionToolSchema', () => {
diff --git a/apps/sim/tools/params.ts b/apps/sim/tools/params.ts
index 991a8296957..f23cefb4e3b 100644
--- a/apps/sim/tools/params.ts
+++ b/apps/sim/tools/params.ts
@@ -123,6 +123,10 @@ export interface ToolSchema {
   required: string[]
 }
 
+export interface UserToolSchemaOptions {
+  surface?: 'default' | 'copilot'
+}
+
 export interface LLMToolSchemaResult {
   schema: ToolSchema
   enrichedDescription?: string
@@ -390,8 +394,15 @@ export function getToolParametersConfig(
 function buildParameterSchema(
   toolId: string,
   paramId: string,
-  param: ToolParamDefinition
+  param: ToolParamDefinition,
+  options: UserToolSchemaOptions = {}
 ): SchemaProperty {
+  const surface = options.surface ?? 'default'
+
+  if (surface === 'copilot' && (param.type === 'file' || param.type === 'file[]')) {
+    return buildCopilotFileParameterSchema(param)
+  }
+
   let schemaType = param.type
   if (schemaType === 'json' || schemaType === 'any') {
     schemaType = 'object'
@@ -416,7 +427,50 @@ function buildParameterSchema(
   return propertySchema
 }
 
-export function createUserToolSchema(toolConfig: ToolConfig): ToolSchema {
+function buildCopilotFileParameterSchema(param: ToolParamDefinition): SchemaProperty {
+  const baseDescription =
+    param.description ||
+    (param.type === 'file'
+      ? 'A file object for tool execution.'
+      : 'An array of file objects for tool execution.')
+  const resolutionDescription =
+    'For copilot and mothership tool calls, prefer passing canonical workspace file IDs such as "wf_123". The runtime will resolve them into full file objects before tool execution.'
+
+  const fileObjectSchema: SchemaProperty = {
+    type: 'object',
+    description: `${baseDescription} ${resolutionDescription}`,
+    properties: {
+      id: { type: 'string', description: 'Canonical workspace file ID.' },
+      name: { type: 'string', description: 'File name.' },
+      url: { type: 'string', description: 'File URL or serve path.' },
+      size: { type: 'number', description: 'File size in bytes.' },
+      type: { type: 'string', description: 'MIME type.' },
+      key: { type: 'string', description: 'Internal storage key.' },
+      context: { type: 'string', description: 'Optional file context.' },
+      base64: { type: 'string', description: 'Optional base64-encoded file contents.' },
+    },
+    required: ['id', 'name', 'url', 'size', 'type', 'key'],
+  }
+
+  if (param.type === 'file') {
+    return fileObjectSchema
+  }
+
+  return {
+    type: 'array',
+    description: `${baseDescription} ${resolutionDescription}`,
+    items: {
+      type: 'object',
+      description: 'A file object.',
+      properties: fileObjectSchema.properties,
+    },
+  }
+}
+
+export function createUserToolSchema(
+  toolConfig: ToolConfig,
+  options: UserToolSchemaOptions = {}
+): ToolSchema {
   const schema: ToolSchema = {
     type: 'object',
     properties: {},
@@ -430,7 +484,7 @@ export function createUserToolSchema(toolConfig: ToolConfig): ToolSchema {
       continue
     }
 
-    const propertySchema = buildParameterSchema(toolConfig.id, paramId, param)
+    const propertySchema = buildParameterSchema(toolConfig.id, paramId, param, options)
     schema.properties[paramId] = propertySchema
 
     if (param.required) {
diff --git a/apps/sim/tools/types.ts b/apps/sim/tools/types.ts
index 48c44535f71..7758f6facc2 100644
--- a/apps/sim/tools/types.ts
+++ b/apps/sim/tools/types.ts
@@ -1,3 +1,4 @@
+import type { MothershipResource } from '@/lib/copilot/resources/types'
 import type { HostedKeyRateLimitConfig } from '@/lib/core/rate-limiter'
 import type { OAuthService } from '@/lib/oauth'
 
@@ -62,6 +63,7 @@ export interface ToolResponse {
   success: boolean // Whether the tool execution was successful
   output: Record<string, any> // The structured output from the tool
   error?: string // Error message if success is false
+  resources?: MothershipResource[] // Resources to auto-open/show in UI
   timing?: {
     startTime: string // ISO timestamp when the tool execution started
     endTime: string // ISO timestamp when the tool execution ended
diff --git a/apps/sim/trigger.config.ts b/apps/sim/trigger.config.ts
index 2f12cf3ab53..aab25af42be 100644
--- a/apps/sim/trigger.config.ts
+++ b/apps/sim/trigger.config.ts
@@ -15,10 +15,14 @@ export default defineConfig({
   },
   dirs: ['./background'],
   build: {
-    external: ['isolated-vm', 'pptxgenjs'],
+    external: ['isolated-vm', 'pptxgenjs', 'docx', 'pdf-lib'],
     extensions: [
       additionalFiles({
-        files: ['./lib/execution/isolated-vm-worker.cjs', './lib/execution/pptx-worker.cjs'],
+        files: [
+          './lib/execution/isolated-vm-worker.cjs',
+          './lib/execution/pptx-worker.cjs',
+          './lib/execution/doc-worker.cjs',
+        ],
       }),
       additionalPackages({
         packages: [
@@ -26,6 +30,7 @@ export default defineConfig({
           'pdf-lib',
           'isolated-vm',
           'pptxgenjs',
+          'docx',
           'react-dom',
           '@react-email/render',
         ],
diff --git a/apps/sim/worker/health.ts b/apps/sim/worker/health.ts
deleted file mode 100644
index f2a5fea3c11..00000000000
--- a/apps/sim/worker/health.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { createServer } from 'http'
-import { createLogger } from '@sim/logger'
-import { getRedisClient } from '@/lib/core/config/redis'
-
-const logger = createLogger('BullMQWorkerHealth')
-
-export interface WorkerHealthServer {
-  close: () => Promise<void>
-}
-
-interface WorkerHealthCheck {
-  redisConnected: boolean
-  dispatcherLastWakeAt: number
-}
-
-let healthState: WorkerHealthCheck = {
-  redisConnected: false,
-  dispatcherLastWakeAt: 0,
-}
-
-export function updateWorkerHealthState(update: Partial<WorkerHealthCheck>): void {
-  healthState = { ...healthState, ...update }
-}
-
-export function startWorkerHealthServer(port: number): WorkerHealthServer {
-  const server = createServer((req, res) => {
-    if (req.method === 'GET' && req.url === '/health') {
-      const redis = getRedisClient()
-      const redisConnected = redis !== null
-      const dispatcherActive =
-        healthState.dispatcherLastWakeAt > 0 &&
-        Date.now() - healthState.dispatcherLastWakeAt < 30_000
-
-      const healthy = redisConnected && dispatcherActive
-
-      res.writeHead(healthy ? 200 : 503, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          ok: healthy,
-          redis: redisConnected,
-          dispatcher: dispatcherActive,
-          lastWakeAgoMs: healthState.dispatcherLastWakeAt
-            ? Date.now() - healthState.dispatcherLastWakeAt
-            : null,
-        })
-      )
-      return
-    }
-
-    if (req.method === 'GET' && req.url === '/health/live') {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(JSON.stringify({ ok: true }))
-      return
-    }
-
-    res.writeHead(404, { 'Content-Type': 'application/json' })
-    res.end(JSON.stringify({ error: 'Not found' }))
-  })
-
-  server.listen(port, '0.0.0.0', () => {
-    logger.info(`Worker health server listening on port ${port}`)
-  })
-
-  return {
-    close: () =>
-      new Promise((resolve, reject) => {
-        server.close((error) => {
-          if (error) {
-            reject(error)
-            return
-          }
-
-          resolve()
-        })
-      }),
-  }
-}
diff --git a/apps/sim/worker/index.ts b/apps/sim/worker/index.ts
deleted file mode 100644
index e5459af3f37..00000000000
--- a/apps/sim/worker/index.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-import { createLogger } from '@sim/logger'
-import { Worker } from 'bullmq'
-import {
-  getBullMQConnectionOptions,
-  isBullMQEnabled,
-  KNOWLEDGE_CONNECTOR_SYNC_QUEUE,
-  KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE,
-  MOTHERSHIP_JOB_EXECUTION_QUEUE,
-  WORKSPACE_NOTIFICATION_DELIVERY_QUEUE,
-} from '@/lib/core/bullmq'
-import { wakeWorkspaceDispatcher } from '@/lib/core/workspace-dispatch'
-import { sweepPendingNotificationDeliveries } from '@/background/workspace-notification-delivery'
-import { startWorkerHealthServer, updateWorkerHealthState } from '@/worker/health'
-import { processKnowledgeConnectorSync } from '@/worker/processors/knowledge-connector-sync'
-import { processKnowledgeDocument } from '@/worker/processors/knowledge-document-processing'
-import { processMothershipJobExecution } from '@/worker/processors/mothership-job-execution'
-import { processResume } from '@/worker/processors/resume'
-import { processSchedule } from '@/worker/processors/schedule'
-import { processWebhook } from '@/worker/processors/webhook'
-import { processWorkflow } from '@/worker/processors/workflow'
-import { processWorkspaceNotificationDelivery } from '@/worker/processors/workspace-notification-delivery'
-
-const logger = createLogger('BullMQWorker')
-
-const DEFAULT_WORKER_PORT = 3001
-const DEFAULT_WORKFLOW_CONCURRENCY = 50
-const DEFAULT_WEBHOOK_CONCURRENCY = 30
-const DEFAULT_SCHEDULE_CONCURRENCY = 20
-const DEFAULT_RESUME_CONCURRENCY = 20
-const DEFAULT_MOTHERSHIP_JOB_CONCURRENCY = 10
-const DEFAULT_CONNECTOR_SYNC_CONCURRENCY = 5
-const DEFAULT_DOCUMENT_PROCESSING_CONCURRENCY = 20
-const DEFAULT_NOTIFICATION_DELIVERY_CONCURRENCY = 10
-const DISPATCHER_WAKE_INTERVAL_MS = 5_000
-const NOTIFICATION_SWEEPER_INTERVAL_MS = 10_000
-
-function parseWorkerNumber(value: string | undefined, fallback: number): number {
-  const parsed = Number.parseInt(value ?? '', 10)
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback
-}
-
-async function main() {
-  const workerPort = parseWorkerNumber(process.env.WORKER_PORT, DEFAULT_WORKER_PORT)
-  const healthServer = startWorkerHealthServer(workerPort)
-
-  if (!isBullMQEnabled()) {
-    logger.warn('BullMQ worker started without REDIS_URL; worker will remain idle')
-
-    const shutdownWithoutRedis = async () => {
-      await healthServer.close()
-      process.exit(0)
-    }
-
-    process.on('SIGINT', shutdownWithoutRedis)
-    process.on('SIGTERM', shutdownWithoutRedis)
-    return
-  }
-
-  const connection = getBullMQConnectionOptions()
-
-  const workflowWorker = new Worker('workflow-execution', processWorkflow, {
-    connection,
-    concurrency: parseWorkerNumber(
-      process.env.WORKER_CONCURRENCY_WORKFLOW,
-      DEFAULT_WORKFLOW_CONCURRENCY
-    ),
-  })
-
-  const webhookWorker = new Worker('webhook-execution', processWebhook, {
-    connection,
-    concurrency: parseWorkerNumber(
-      process.env.WORKER_CONCURRENCY_WEBHOOK,
-      DEFAULT_WEBHOOK_CONCURRENCY
-    ),
-  })
-
-  const scheduleWorker = new Worker('schedule-execution', processSchedule, {
-    connection,
-    concurrency: parseWorkerNumber(
-      process.env.WORKER_CONCURRENCY_SCHEDULE,
-      DEFAULT_SCHEDULE_CONCURRENCY
-    ),
-  })
-
-  const resumeWorker = new Worker('resume-execution', processResume, {
-    connection,
-    concurrency: parseWorkerNumber(
-      process.env.WORKER_CONCURRENCY_RESUME,
-      DEFAULT_RESUME_CONCURRENCY
-    ),
-  })
-
-  const mothershipJobWorker = new Worker(
-    MOTHERSHIP_JOB_EXECUTION_QUEUE,
-    processMothershipJobExecution,
-    {
-      connection,
-      concurrency: parseWorkerNumber(
-        process.env.WORKER_CONCURRENCY_MOTHERSHIP_JOB,
-        DEFAULT_MOTHERSHIP_JOB_CONCURRENCY
-      ),
-    }
-  )
-
-  const connectorSyncWorker = new Worker(
-    KNOWLEDGE_CONNECTOR_SYNC_QUEUE,
-    processKnowledgeConnectorSync,
-    {
-      connection,
-      concurrency: parseWorkerNumber(
-        process.env.WORKER_CONCURRENCY_CONNECTOR_SYNC,
-        DEFAULT_CONNECTOR_SYNC_CONCURRENCY
-      ),
-    }
-  )
-
-  const documentProcessingWorker = new Worker(
-    KNOWLEDGE_DOCUMENT_PROCESSING_QUEUE,
-    processKnowledgeDocument,
-    {
-      connection,
-      concurrency: parseWorkerNumber(
-        process.env.WORKER_CONCURRENCY_DOCUMENT_PROCESSING,
-        DEFAULT_DOCUMENT_PROCESSING_CONCURRENCY
-      ),
-    }
-  )
-
-  const notificationDeliveryWorker = new Worker(
-    WORKSPACE_NOTIFICATION_DELIVERY_QUEUE,
-    processWorkspaceNotificationDelivery,
-    {
-      connection,
-      concurrency: parseWorkerNumber(
-        process.env.WORKER_CONCURRENCY_NOTIFICATION_DELIVERY,
-        DEFAULT_NOTIFICATION_DELIVERY_CONCURRENCY
-      ),
-    }
-  )
-
-  const workers = [
-    workflowWorker,
-    webhookWorker,
-    scheduleWorker,
-    resumeWorker,
-    mothershipJobWorker,
-    connectorSyncWorker,
-    documentProcessingWorker,
-    notificationDeliveryWorker,
-  ]
-
-  for (const worker of workers) {
-    worker.on('failed', (job, error) => {
-      logger.error('BullMQ job failed', {
-        queue: worker.name,
-        jobId: job?.id,
-        name: job?.name,
-        error: error.message,
-      })
-    })
-  }
-
-  const dispatcherWakeInterval = setInterval(() => {
-    void wakeWorkspaceDispatcher()
-      .then(() => {
-        updateWorkerHealthState({ dispatcherLastWakeAt: Date.now() })
-      })
-      .catch((error) => {
-        logger.error('Periodic workspace dispatcher wake failed', { error })
-      })
-  }, DISPATCHER_WAKE_INTERVAL_MS)
-  dispatcherWakeInterval.unref()
-
-  const notificationSweeperInterval = setInterval(() => {
-    void sweepPendingNotificationDeliveries().catch((error) => {
-      logger.error('Pending notification sweeper failed', { error })
-    })
-  }, NOTIFICATION_SWEEPER_INTERVAL_MS)
-  notificationSweeperInterval.unref()
-
-  const shutdown = async () => {
-    logger.info('Shutting down BullMQ worker')
-
-    clearInterval(dispatcherWakeInterval)
-    clearInterval(notificationSweeperInterval)
-    await Promise.allSettled(workers.map((worker) => worker.close()))
-    await healthServer.close()
-
-    process.exit(0)
-  }
-
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
-}
-
-main().catch((error) => {
-  logger.error('Failed to start BullMQ worker', {
-    error: error instanceof Error ? error.message : String(error),
-  })
-  process.exit(1)
-})
diff --git a/apps/sim/worker/processors/knowledge-connector-sync.ts b/apps/sim/worker/processors/knowledge-connector-sync.ts
deleted file mode 100644
index 9a504ebde0f..00000000000
--- a/apps/sim/worker/processors/knowledge-connector-sync.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import { executeSync } from '@/lib/knowledge/connectors/sync-engine'
-import type { ConnectorSyncPayload } from '@/background/knowledge-connector-sync'
-
-const logger = createLogger('BullMQKnowledgeConnectorSync')
-
-export async function processKnowledgeConnectorSync(job: Job<BullMQJobData<ConnectorSyncPayload>>) {
-  const { connectorId, fullSync } = job.data.payload
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing connector sync job', {
-    jobId: job.id,
-    connectorId,
-  })
-
-  return runDispatchedJob(job.data.metadata, () => executeSync(connectorId, { fullSync }), {
-    isFinalAttempt,
-  })
-}
diff --git a/apps/sim/worker/processors/knowledge-document-processing.ts b/apps/sim/worker/processors/knowledge-document-processing.ts
deleted file mode 100644
index 74fff94fb7b..00000000000
--- a/apps/sim/worker/processors/knowledge-document-processing.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import { type DocumentJobData, processDocumentAsync } from '@/lib/knowledge/documents/service'
-
-const logger = createLogger('BullMQKnowledgeDocumentProcessing')
-
-export async function processKnowledgeDocument(job: Job<BullMQJobData<DocumentJobData>>) {
-  const { knowledgeBaseId, documentId, docData, processingOptions } = job.data.payload
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing knowledge document job', {
-    jobId: job.id,
-    knowledgeBaseId,
-    documentId,
-  })
-
-  await runDispatchedJob(
-    job.data.metadata,
-    () => processDocumentAsync(knowledgeBaseId, documentId, docData, processingOptions),
-    {
-      isFinalAttempt,
-    }
-  )
-}
diff --git a/apps/sim/worker/processors/mothership-job-execution.ts b/apps/sim/worker/processors/mothership-job-execution.ts
deleted file mode 100644
index d5980394388..00000000000
--- a/apps/sim/worker/processors/mothership-job-execution.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import { executeJobInline, type JobExecutionPayload } from '@/background/schedule-execution'
-
-const logger = createLogger('BullMQMothershipJobExecution')
-
-export async function processMothershipJobExecution(job: Job<BullMQJobData<JobExecutionPayload>>) {
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing mothership scheduled job', {
-    jobId: job.id,
-    scheduleId: job.data.payload.scheduleId,
-  })
-
-  await runDispatchedJob(job.data.metadata, () => executeJobInline(job.data.payload), {
-    isFinalAttempt,
-  })
-}
diff --git a/apps/sim/worker/processors/resume.ts b/apps/sim/worker/processors/resume.ts
deleted file mode 100644
index d5dba569bb9..00000000000
--- a/apps/sim/worker/processors/resume.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import { executeResumeJob, type ResumeExecutionPayload } from '@/background/resume-execution'
-
-const logger = createLogger('BullMQResumeProcessor')
-
-export async function processResume(job: Job<BullMQJobData<ResumeExecutionPayload>>) {
-  const { payload } = job.data
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing resume execution job', {
-    jobId: job.id,
-    resumeExecutionId: payload.resumeExecutionId,
-    workflowId: payload.workflowId,
-  })
-
-  return runDispatchedJob(job.data.metadata, () => executeResumeJob(payload), {
-    isFinalAttempt,
-  })
-}
diff --git a/apps/sim/worker/processors/schedule.ts b/apps/sim/worker/processors/schedule.ts
deleted file mode 100644
index 78f4cde7d79..00000000000
--- a/apps/sim/worker/processors/schedule.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import { executeScheduleJob, type ScheduleExecutionPayload } from '@/background/schedule-execution'
-
-const logger = createLogger('BullMQScheduleProcessor')
-
-export async function processSchedule(job: Job<BullMQJobData<ScheduleExecutionPayload>>) {
-  const { payload } = job.data
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing schedule job', {
-    jobId: job.id,
-    name: job.name,
-  })
-
-  return runDispatchedJob(job.data.metadata, () => executeScheduleJob(payload), {
-    isFinalAttempt,
-  })
-}
diff --git a/apps/sim/worker/processors/webhook.ts b/apps/sim/worker/processors/webhook.ts
deleted file mode 100644
index da61aede1c8..00000000000
--- a/apps/sim/worker/processors/webhook.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import { executeWebhookJob, type WebhookExecutionPayload } from '@/background/webhook-execution'
-
-const logger = createLogger('BullMQWebhookProcessor')
-
-export async function processWebhook(job: Job<BullMQJobData<WebhookExecutionPayload>>) {
-  const { payload } = job.data
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing webhook job', {
-    jobId: job.id,
-    name: job.name,
-  })
-
-  return runDispatchedJob(job.data.metadata, () => executeWebhookJob(payload), {
-    isFinalAttempt,
-  })
-}
diff --git a/apps/sim/worker/processors/workflow.ts b/apps/sim/worker/processors/workflow.ts
deleted file mode 100644
index 8648e76b556..00000000000
--- a/apps/sim/worker/processors/workflow.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import {
-  DIRECT_WORKFLOW_JOB_NAME,
-  executeQueuedWorkflowJob,
-  type QueuedWorkflowExecutionPayload,
-} from '@/lib/workflows/executor/queued-workflow-execution'
-import { executeWorkflowJob, type WorkflowExecutionPayload } from '@/background/workflow-execution'
-
-const logger = createLogger('BullMQWorkflowProcessor')
-
-type WorkflowQueueJobData =
-  | BullMQJobData<QueuedWorkflowExecutionPayload>
-  | BullMQJobData<WorkflowExecutionPayload>
-
-function isDirectWorkflowJob(
-  job: Job<WorkflowQueueJobData>
-): job is Job<BullMQJobData<QueuedWorkflowExecutionPayload>> {
-  return job.name === DIRECT_WORKFLOW_JOB_NAME
-}
-
-function isBackgroundWorkflowJob(
-  job: Job<WorkflowQueueJobData>
-): job is Job<BullMQJobData<WorkflowExecutionPayload>> {
-  return job.name !== DIRECT_WORKFLOW_JOB_NAME
-}
-
-export async function processWorkflow(job: Job<WorkflowQueueJobData>) {
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing workflow job', {
-    jobId: job.id,
-    name: job.name,
-  })
-
-  if (isDirectWorkflowJob(job)) {
-    return runDispatchedJob(job.data.metadata, () => executeQueuedWorkflowJob(job.data.payload), {
-      isFinalAttempt,
-    })
-  }
-
-  if (isBackgroundWorkflowJob(job)) {
-    return runDispatchedJob(job.data.metadata, () => executeWorkflowJob(job.data.payload), {
-      isFinalAttempt,
-    })
-  }
-
-  throw new Error(`Unsupported workflow job type: ${job.name}`)
-}
diff --git a/apps/sim/worker/processors/workspace-notification-delivery.ts b/apps/sim/worker/processors/workspace-notification-delivery.ts
deleted file mode 100644
index 7b6dbbc6da1..00000000000
--- a/apps/sim/worker/processors/workspace-notification-delivery.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { createLogger } from '@sim/logger'
-import type { Job } from 'bullmq'
-import type { BullMQJobData } from '@/lib/core/bullmq'
-import { runDispatchedJob } from '@/lib/core/workspace-dispatch'
-import {
-  executeNotificationDelivery,
-  type NotificationDeliveryParams,
-} from '@/background/workspace-notification-delivery'
-
-const logger = createLogger('BullMQWorkspaceNotificationDelivery')
-
-export async function processWorkspaceNotificationDelivery(
-  job: Job<BullMQJobData<NotificationDeliveryParams>>
-) {
-  const isFinalAttempt = job.attemptsMade + 1 >= (job.opts.attempts ?? 1)
-
-  logger.info('Processing workspace notification delivery job', {
-    jobId: job.id,
-    deliveryId: job.data.payload.deliveryId,
-  })
-
-  const result = await runDispatchedJob(
-    job.data.metadata,
-    () => executeNotificationDelivery(job.data.payload),
-    {
-      isFinalAttempt,
-    }
-  )
-
-  // Retry scheduling is persisted in the notification delivery row and
-  // rehydrated by the periodic sweeper, which makes retries crash-safe.
-}
diff --git a/bun.lock b/bun.lock
index e05bc532f5e..9f8b09f5bf3 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,6 +1,5 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "simstudio",
@@ -12,6 +11,7 @@
         "@octokit/rest": "^21.0.0",
         "glob": "13.0.0",
         "husky": "9.1.7",
+        "json-schema-to-typescript": "15.0.4",
         "lint-staged": "16.0.0",
         "turbo": "2.9.3",
       },
@@ -120,11 +120,11 @@
         "@trigger.dev/sdk": "4.4.3",
         "@types/react-window": "2.0.0",
         "@types/three": "0.177.0",
+        "ajv": "8.18.0",
         "better-auth": "1.3.12",
         "better-auth-harmony": "1.3.1",
         "binary-extensions": "^2.0.0",
         "browser-image-compression": "^2.0.2",
-        "bullmq": "5.71.0",
         "chalk": "5.6.2",
         "chart.js": "4.5.1",
         "cheerio": "1.1.2",
@@ -136,6 +136,8 @@
         "csv-parse": "6.1.0",
         "date-fns": "4.1.0",
         "decimal.js": "10.6.0",
+        "docx": "^9.6.1",
+        "docx-preview": "^0.3.7",
         "drizzle-orm": "^0.44.5",
         "encoding": "0.1.13",
         "entities": "6.0.1",
@@ -188,7 +190,6 @@
         "react-dom": "19.2.4",
         "react-hook-form": "^7.54.2",
         "react-joyride": "2.9.3",
-        "react-markdown": "^10.1.0",
         "react-simple-code-editor": "^0.14.1",
         "react-window": "2.2.3",
         "reactflow": "^11.11.4",
@@ -205,6 +206,7 @@
         "socket.io": "^4.8.1",
         "socket.io-client": "4.8.1",
         "ssh2": "^1.17.0",
+        "streamdown": "2.5.0",
         "stripe": "18.5.0",
         "svix": "1.88.0",
         "tailwind-merge": "^2.6.0",
@@ -390,8 +392,12 @@
 
     "@ampproject/remapping": ["@ampproject/remapping@2.3.0", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw=="],
 
+    "@antfu/install-pkg": ["@antfu/install-pkg@1.1.0", "", { "dependencies": { "package-manager-detector": "^1.3.0", "tinyexec": "^1.0.1" } }, "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ=="],
+
     "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.71.2", "", { "dependencies": { "json-schema-to-ts": "^3.1.1" }, "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" }, "optionalPeers": ["zod"], "bin": { "anthropic-ai-sdk": "bin/cli" } }, "sha512-TGNDEUuEstk/DKu0/TflXAEt+p+p/WhTlFzEnoosvbaDU2LTjm42igSdlL0VijrKpWejtOKxX0b8A7uc+XiSAQ=="],
 
+    "@apidevtools/json-schema-ref-parser": ["@apidevtools/json-schema-ref-parser@11.9.3", "", { "dependencies": { "@jsdevtools/ono": "^7.1.3", "@types/json-schema": "^7.0.15", "js-yaml": "^4.1.0" } }, "sha512-60vepv88RwcJtSHrD6MjIL6Ta3SOYbgfnkHb+ppAVK+o9mXprRtulx7VlRl3lN3bbvysAfCS7WMVfhUYemB0IQ=="],
+
     "@ark/schema": ["@ark/schema@0.56.0", "", { "dependencies": { "@ark/util": "0.56.0" } }, "sha512-ECg3hox/6Z/nLajxXqNhgPtNdHWC9zNsDyskwO28WinoFEnWow4IsERNz9AnXRhTZJnYIlAJ4uGn3nlLk65vZA=="],
 
     "@ark/util": ["@ark/util@0.56.0", "", {}, "sha512-BghfRC8b9pNs3vBoDJhcta0/c1J1rsoS1+HgVUreMFPdhz/CRAKReAu57YEllNaSy98rWAdY1gE+gFup7OXpgA=="],
@@ -620,6 +626,8 @@
 
     "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.0.0-beta.5", "", { "os": "win32", "cpu": "x64" }, "sha512-N7Yby52BJmvEdst1iMbclE5hxxefboaXKRJLm1tLfBYr4FeuoCe6j8HdiQSwhCRdIUGFFqBLaDXh//LLF6EReA=="],
 
+    "@braintree/sanitize-url": ["@braintree/sanitize-url@7.1.2", "", {}, "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA=="],
+
     "@browserbasehq/sdk": ["@browserbasehq/sdk@2.9.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-Xzm1+6suzQypXjley4Phqer++pjnYyST6S7CArUn3kWyGA8aruXjAV5wkmqE21lgXo9K3/OQJvCu48bKEZFNDQ=="],
 
     "@browserbasehq/stagehand": ["@browserbasehq/stagehand@3.2.0", "", { "dependencies": { "@ai-sdk/provider": "^2.0.0", "@anthropic-ai/sdk": "0.39.0", "@browserbasehq/sdk": "^2.7.0", "@google/genai": "^1.22.0", "@langchain/openai": "^0.4.4", "@modelcontextprotocol/sdk": "^1.17.2", "ai": "^5.0.133", "devtools-protocol": "^0.0.1464554", "fetch-cookie": "^3.1.0", "openai": "^4.87.1", "pino": "^9.6.0", "pino-pretty": "^13.0.0", "uuid": "^11.1.0", "ws": "^8.18.0", "zod-to-json-schema": "^3.25.0" }, "optionalDependencies": { "@ai-sdk/amazon-bedrock": "^3.0.73", "@ai-sdk/anthropic": "^2.0.34", "@ai-sdk/azure": "^2.0.54", "@ai-sdk/cerebras": "^1.0.25", "@ai-sdk/deepseek": "^1.0.23", "@ai-sdk/google": "^2.0.53", "@ai-sdk/google-vertex": "^3.0.70", "@ai-sdk/groq": "^2.0.24", "@ai-sdk/mistral": "^2.0.19", "@ai-sdk/openai": "^2.0.53", "@ai-sdk/perplexity": "^2.0.13", "@ai-sdk/togetherai": "^1.0.23", "@ai-sdk/xai": "^2.0.26", "@langchain/core": "^0.3.80", "bufferutil": "^4.0.9", "chrome-launcher": "^1.2.0", "ollama-ai-provider-v2": "^1.5.0", "patchright-core": "^1.55.2", "playwright": "^1.52.0", "playwright-core": "^1.54.1", "puppeteer-core": "^22.8.0" }, "peerDependencies": { "deepmerge": "^4.3.1", "zod": "^3.25.76 || ^4.2.0" } }, "sha512-X9s3sZuTL3zf8gt1o9yr4mvT2JmDRigkmBinlKF6LD+rlAIOh+nH6Cmz6xfRjZ4RgTfR0wRoE1iUTKa39YtWfA=="],
@@ -632,6 +640,16 @@
 
     "@cfworker/json-schema": ["@cfworker/json-schema@4.1.1", "", {}, "sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og=="],
 
+    "@chevrotain/cst-dts-gen": ["@chevrotain/cst-dts-gen@12.0.0", "", { "dependencies": { "@chevrotain/gast": "12.0.0", "@chevrotain/types": "12.0.0" } }, "sha512-fSL4KXjTl7cDgf0B5Rip9Q05BOrYvkJV/RrBTE/bKDN096E4hN/ySpcBK5B24T76dlQ2i32Zc3PAE27jFnFrKg=="],
+
+    "@chevrotain/gast": ["@chevrotain/gast@12.0.0", "", { "dependencies": { "@chevrotain/types": "12.0.0" } }, "sha512-1ne/m3XsIT8aEdrvT33so0GUC+wkctpUPK6zU9IlOyJLUbR0rg4G7ZiApiJbggpgPir9ERy3FRjT6T7lpgetnQ=="],
+
+    "@chevrotain/regexp-to-ast": ["@chevrotain/regexp-to-ast@12.0.0", "", {}, "sha512-p+EW9MaJwgaHguhoqwOtx/FwuGr+DnNn857sXWOi/mClXIkPGl3rn7hGNWvo31HA3vyeQxjqe+H36yZJwYU8cA=="],
+
+    "@chevrotain/types": ["@chevrotain/types@12.0.0", "", {}, "sha512-S+04vjFQKeuYw0/eW3U52LkAHQsB1ASxsPGsLPUyQgrZ2iNNibQrsidruDzjEX2JYfespXMG0eZmXlhA6z7nWA=="],
+
+    "@chevrotain/utils": ["@chevrotain/utils@12.0.0", "", {}, "sha512-lB59uJoaGIfOOL9knQqQRfhl9g7x8/wqFkp13zTdkRu1huG9kg6IJs1O8hqj9rs6h7orGxHJUKb+mX3rPbWGhA=="],
+
     "@connectrpc/connect": ["@connectrpc/connect@2.0.0-rc.3", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.2.0" } }, "sha512-ARBt64yEyKbanyRETTjcjJuHr2YXorzQo0etyS5+P6oSeW8xEuzajA9g+zDnMcj1hlX2dQE93foIWQGfpru7gQ=="],
 
     "@connectrpc/connect-web": ["@connectrpc/connect-web@2.0.0-rc.3", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.2.0", "@connectrpc/connect": "2.0.0-rc.3" } }, "sha512-w88P8Lsn5CCsA7MFRl2e6oLY4J/5toiNtJns/YJrlyQaWOy3RO8pDgkz+iIkG98RPMhj2thuBvsd3Cn4DKKCkw=="],
@@ -748,6 +766,10 @@
 
     "@hookform/resolvers": ["@hookform/resolvers@4.1.3", "", { "dependencies": { "@standard-schema/utils": "^0.3.0" }, "peerDependencies": { "react-hook-form": "^7.0.0" } }, "sha512-Jsv6UOWYTrEFJ/01ZrnwVXs7KDvP8XIo115i++5PWvNkNvkrsTfGiLS6w+eJ57CYtUtDQalUWovCZDHFJ8u1VQ=="],
 
+    "@iconify/types": ["@iconify/types@2.0.0", "", {}, "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg=="],
+
+    "@iconify/utils": ["@iconify/utils@3.1.0", "", { "dependencies": { "@antfu/install-pkg": "^1.1.0", "@iconify/types": "^2.0.0", "mlly": "^1.8.0" } }, "sha512-Zlzem1ZXhI1iHeeERabLNzBHdOa4VhQbqAcOQaMKuTuyZCpwKbC2R4Dd0Zo3g9EAc+Y4fiarO8HIHRAth7+skw=="],
+
     "@img/colour": ["@img/colour@1.1.0", "", {}, "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ=="],
 
     "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.3", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.0" }, "os": "darwin", "cpu": "arm64" }, "sha512-ryFMfvxxpQRsgZJqBd4wsttYQbCxsJksrv9Lw/v798JcQ8+w84mBWuXwl+TT0WJ/WrYOLaYpwQXi3sA9nTIaIg=="],
@@ -820,6 +842,8 @@
 
     "@js-sdsl/ordered-map": ["@js-sdsl/ordered-map@4.4.2", "", {}, "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw=="],
 
+    "@jsdevtools/ono": ["@jsdevtools/ono@7.1.3", "", {}, "sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg=="],
+
     "@jsonhero/path": ["@jsonhero/path@1.0.21", "", {}, "sha512-gVUDj/92acpVoJwsVJ/RuWOaHyG4oFzn898WNGQItLCTQ+hOaVlEaImhwE1WqOTf+l3dGOUkbSiVKlb3q1hd1Q=="],
 
     "@kurkle/color": ["@kurkle/color@0.3.4", "", {}, "sha512-M5UknZPHRu3DEDWoipU6sE8PdkZ6Z/S+v4dD+Ke8IaNlpdSQah50lz1KtcFBa2vsdOnwbbnxJwVM4wty6udA5w=="],
@@ -838,24 +862,14 @@
 
     "@mdx-js/react": ["@mdx-js/react@3.1.1", "", { "dependencies": { "@types/mdx": "^2.0.0" }, "peerDependencies": { "@types/react": ">=16", "react": ">=16" } }, "sha512-f++rKLQgUVYDAtECQ6fn/is15GkEH9+nZPM3MS0RcxVqoTfawHvDlSCH7JbMhAM6uJ32v3eXLvLmLvjGu7PTQw=="],
 
+    "@mermaid-js/parser": ["@mermaid-js/parser@1.1.0", "", { "dependencies": { "langium": "^4.0.0" } }, "sha512-gxK9ZX2+Fex5zu8LhRQoMeMPEHbc73UKZ0FQ54YrQtUxE1VVhMwzeNtKRPAu5aXks4FasbMe4xB4bWrmq6Jlxw=="],
+
     "@microsoft/fetch-event-source": ["@microsoft/fetch-event-source@2.0.1", "", {}, "sha512-W6CLUJ2eBMw3Rec70qrsEW0jOm/3twwJv21mrmj2yORiaVmVYGS4sSS5yUwvQc1ZlDLYGPnClVWmUUMagKNsfA=="],
 
     "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.20.2", "", { "dependencies": { "ajv": "^6.12.6", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.0.1", "express-rate-limit": "^7.5.0", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.23.8", "zod-to-json-schema": "^3.24.1" } }, "sha512-6rqTdFt67AAAzln3NOKsXRmv5ZzPkgbfaebKBqUbts7vK1GZudqnrun5a8d3M/h955cam9RHZ6Jb4Y1XhnmFPg=="],
 
     "@mongodb-js/saslprep": ["@mongodb-js/saslprep@1.4.6", "", { "dependencies": { "sparse-bitfield": "^3.0.3" } }, "sha512-y+x3H1xBZd38n10NZF/rEBlvDOOMQ6LKUTHqr8R9VkJ+mmQOYtJFxIlkkK8fZrtOiL6VixbOBWMbZGBdal3Z1g=="],
 
-    "@msgpackr-extract/msgpackr-extract-darwin-arm64": ["@msgpackr-extract/msgpackr-extract-darwin-arm64@3.0.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-QZHtlVgbAdy2zAqNA9Gu1UpIuI8Xvsd1v8ic6B2pZmeFnFcMWiPLfWXh7TVw4eGEZ/C9TH281KwhVoeQUKbyjw=="],
-
-    "@msgpackr-extract/msgpackr-extract-darwin-x64": ["@msgpackr-extract/msgpackr-extract-darwin-x64@3.0.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-mdzd3AVzYKuUmiWOQ8GNhl64/IoFGol569zNRdkLReh6LRLHOXxU4U8eq0JwaD8iFHdVGqSy4IjFL4reoWCDFw=="],
-
-    "@msgpackr-extract/msgpackr-extract-linux-arm": ["@msgpackr-extract/msgpackr-extract-linux-arm@3.0.3", "", { "os": "linux", "cpu": "arm" }, "sha512-fg0uy/dG/nZEXfYilKoRe7yALaNmHoYeIoJuJ7KJ+YyU2bvY8vPv27f7UKhGRpY6euFYqEVhxCFZgAUNQBM3nw=="],
-
-    "@msgpackr-extract/msgpackr-extract-linux-arm64": ["@msgpackr-extract/msgpackr-extract-linux-arm64@3.0.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-YxQL+ax0XqBJDZiKimS2XQaf+2wDGVa1enVRGzEvLLVFeqa5kx2bWbtcSXgsxjQB7nRqqIGFIcLteF/sHeVtQg=="],
-
-    "@msgpackr-extract/msgpackr-extract-linux-x64": ["@msgpackr-extract/msgpackr-extract-linux-x64@3.0.3", "", { "os": "linux", "cpu": "x64" }, "sha512-cvwNfbP07pKUfq1uH+S6KJ7dT9K8WOE4ZiAcsrSes+UY55E/0jLYc+vq+DO7jlmqRb5zAggExKm0H7O/CBaesg=="],
-
-    "@msgpackr-extract/msgpackr-extract-win32-x64": ["@msgpackr-extract/msgpackr-extract-win32-x64@3.0.3", "", { "os": "win32", "cpu": "x64" }, "sha512-x0fWaQtYp4E6sktbsdAqnehxDgEc/VwM7uLsRCYWaiGu0ykYdZPiS8zCWdnjHwyiumousxfBm4SO31eXqwEZhQ=="],
-
     "@napi-rs/canvas": ["@napi-rs/canvas@0.1.97", "", { "optionalDependencies": { "@napi-rs/canvas-android-arm64": "0.1.97", "@napi-rs/canvas-darwin-arm64": "0.1.97", "@napi-rs/canvas-darwin-x64": "0.1.97", "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.97", "@napi-rs/canvas-linux-arm64-gnu": "0.1.97", "@napi-rs/canvas-linux-arm64-musl": "0.1.97", "@napi-rs/canvas-linux-riscv64-gnu": "0.1.97", "@napi-rs/canvas-linux-x64-gnu": "0.1.97", "@napi-rs/canvas-linux-x64-musl": "0.1.97", "@napi-rs/canvas-win32-arm64-msvc": "0.1.97", "@napi-rs/canvas-win32-x64-msvc": "0.1.97" } }, "sha512-8cFniXvrIEnVwuNSRCW9wirRZbHvrD3JVujdS2P5n5xiJZNZMOZcfOvJ1pb66c7jXMKHHglJEDVJGbm8XWFcXQ=="],
 
     "@napi-rs/canvas-android-arm64": ["@napi-rs/canvas-android-arm64@0.1.97", "", { "os": "android", "cpu": "arm64" }, "sha512-V1c/WVw+NzH8vk7ZK/O8/nyBSCQimU8sfMsB/9qeSvdkGKNU7+mxy/bIF0gTgeBFmHpj30S4E9WHMSrxXGQuVQ=="],
@@ -1614,6 +1628,8 @@
 
     "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
 
+    "@types/lodash": ["@types/lodash@4.17.24", "", {}, "sha512-gIW7lQLZbue7lRSWEFql49QJJWThrTFFeIMJdp3eH4tKoxm1OvEPg02rm4wCCSHS0cL3/Fizimb35b7k8atwsQ=="],
+
     "@types/mdast": ["@types/mdast@4.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA=="],
 
     "@types/mdx": ["@types/mdx@2.0.13", "", {}, "sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw=="],
@@ -1672,6 +1688,8 @@
 
     "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="],
 
+    "@upsetjs/venn.js": ["@upsetjs/venn.js@2.0.0", "", { "optionalDependencies": { "d3-selection": "^3.0.0", "d3-transition": "^3.0.1" } }, "sha512-WbBhLrooyePuQ1VZxrJjtLvTc4NVfpOyKx0sKqioq9bX1C1m7Jgykkn8gLrtwumBioXIqam8DLxp88Adbue6Hw=="],
+
     "@vercel/og": ["@vercel/og@0.6.8", "", { "dependencies": { "@resvg/resvg-wasm": "2.4.0", "satori": "0.12.2", "yoga-wasm-web": "0.3.3" } }, "sha512-e4kQK9mP8ntpo3dACWirGod/hHv4qO5JMj9a/0a2AZto7b4persj5YP7t1Er372gTtYFTYxNhMx34jRvHooglw=="],
 
     "@vercel/oidc": ["@vercel/oidc@3.1.0", "", {}, "sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w=="],
@@ -1860,8 +1878,6 @@
 
     "buildcheck": ["buildcheck@0.0.7", "", {}, "sha512-lHblz4ahamxpTmnsk+MNTRWsjYKv965MwOrSJyeD588rR3Jcu7swE+0wN5F+PbL5cjgu/9ObkhfzEPuofEMwLA=="],
 
-    "bullmq": ["bullmq@5.71.0", "", { "dependencies": { "cron-parser": "4.9.0", "ioredis": "5.9.3", "msgpackr": "1.11.5", "node-abort-controller": "3.1.1", "semver": "7.7.4", "tslib": "2.8.1", "uuid": "11.1.0" } }, "sha512-aeNWh4drsafSKnAJeiNH/nZP/5O8ZdtdMbnOPZmpjXj7NZUP5YC901U3bIH41iZValm7d1i3c34ojv7q31m30w=="],
-
     "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
 
     "c12": ["c12@3.1.0", "", { "dependencies": { "chokidar": "^4.0.3", "confbox": "^0.2.2", "defu": "^6.1.4", "dotenv": "^16.6.1", "exsolve": "^1.0.7", "giget": "^2.0.0", "jiti": "^2.4.2", "ohash": "^2.0.11", "pathe": "^2.0.3", "perfect-debounce": "^1.0.0", "pkg-types": "^2.2.0", "rc9": "^2.1.2" }, "peerDependencies": { "magicast": "^0.3.5" }, "optionalPeers": ["magicast"] }, "sha512-uWoS8OU1MEIsOv8p/5a82c3H31LsWVR5qiyXVfBNOzfffjUWtPnhAb4BYI2uG2HfGmZmFjCtui5XNWaps+iFuw=="],
@@ -1908,6 +1924,10 @@
 
     "cheerio-select": ["cheerio-select@2.1.0", "", { "dependencies": { "boolbase": "^1.0.0", "css-select": "^5.1.0", "css-what": "^6.1.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1" } }, "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g=="],
 
+    "chevrotain": ["chevrotain@12.0.0", "", { "dependencies": { "@chevrotain/cst-dts-gen": "12.0.0", "@chevrotain/gast": "12.0.0", "@chevrotain/regexp-to-ast": "12.0.0", "@chevrotain/types": "12.0.0", "@chevrotain/utils": "12.0.0" } }, "sha512-csJvb+6kEiQaqo1woTdSAuOWdN0WTLIydkKrBnS+V5gZz0oqBrp4kQ35519QgK6TpBThiG3V1vNSHlIkv4AglQ=="],
+
+    "chevrotain-allstar": ["chevrotain-allstar@0.4.1", "", { "dependencies": { "lodash-es": "^4.17.21" }, "peerDependencies": { "chevrotain": "^12.0.0" } }, "sha512-PvVJm3oGqrveUVW2Vt/eZGeiAIsJszYweUcYwcskg9e+IubNYKKD+rHHem7A6XVO22eDAL+inxNIGAzZ/VIWlA=="],
+
     "chokidar": ["chokidar@5.0.0", "", { "dependencies": { "readdirp": "^5.0.0" } }, "sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw=="],
 
     "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="],
@@ -1994,14 +2014,14 @@
 
     "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="],
 
+    "cose-base": ["cose-base@1.0.3", "", { "dependencies": { "layout-base": "^1.0.0" } }, "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg=="],
+
     "cpu-features": ["cpu-features@0.0.10", "", { "dependencies": { "buildcheck": "~0.0.6", "nan": "^2.19.0" } }, "sha512-9IkYqtX3YHPCzoVg1Py+o9057a3i0fp7S530UWokCSaFVTc7CwXPRiOjRjBQQ18ZCNafx78YfnG+HALxtVmOGA=="],
 
     "crc-32": ["crc-32@1.2.2", "", { "bin": { "crc32": "bin/crc32.njs" } }, "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ=="],
 
     "critters": ["critters@0.0.25", "", { "dependencies": { "chalk": "^4.1.0", "css-select": "^5.1.0", "dom-serializer": "^2.0.0", "domhandler": "^5.0.2", "htmlparser2": "^8.0.2", "postcss": "^8.4.23", "postcss-media-query-parser": "^0.2.3" } }, "sha512-ROF/tjJyyRdM8/6W0VqoN5Ql05xAGnkf5b7f3sTEl1bI5jTQQf8O918RD/V9tEb9pRY/TKcvJekDbJtniHyPtQ=="],
 
-    "cron-parser": ["cron-parser@4.9.0", "", { "dependencies": { "luxon": "^3.2.1" } }, "sha512-p0SaNjrHOnQeR8/VnfGbmg9te2kfyYSQ7Sc/j/6DtPL3JQvKxmjO9TSjNFpujqV3vEYYBvNNvXSxzyksBWAx1Q=="],
-
     "croner": ["croner@9.1.0", "", {}, "sha512-p9nwwR4qyT5W996vBZhdvBCnMhicY5ytZkR4D1Xj0wuTDEiMnjwR57Q3RXYY/s0EpX6Ay3vgIcfaR+ewGHsi+g=="],
 
     "cronstrue": ["cronstrue@3.3.0", "", { "bin": { "cronstrue": "bin/cli.js" } }, "sha512-iwJytzJph1hosXC09zY8F5ACDJKerr0h3/2mOxg9+5uuFObYlgK0m35uUPk4GCvhHc2abK7NfnR9oMqY0qZFAg=="],
@@ -2032,24 +2052,78 @@
 
     "csv-parse": ["csv-parse@6.1.0", "", {}, "sha512-CEE+jwpgLn+MmtCpVcPtiCZpVtB6Z2OKPTr34pycYYoL7sxdOkXDdQ4lRiw6ioC0q6BLqhc6cKweCVvral8yhw=="],
 
+    "cytoscape": ["cytoscape@3.33.2", "", {}, "sha512-sj4HXd3DokGhzZAdjDejGvTPLqlt84vNFN8m7bGsOzDY5DyVcxIb2ejIXat2Iy7HxWhdT/N1oKyheJ5YdpsGuw=="],
+
+    "cytoscape-cose-bilkent": ["cytoscape-cose-bilkent@4.1.0", "", { "dependencies": { "cose-base": "^1.0.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ=="],
+
+    "cytoscape-fcose": ["cytoscape-fcose@2.2.0", "", { "dependencies": { "cose-base": "^2.2.0" }, "peerDependencies": { "cytoscape": "^3.2.0" } }, "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ=="],
+
+    "d3": ["d3@7.9.0", "", { "dependencies": { "d3-array": "3", "d3-axis": "3", "d3-brush": "3", "d3-chord": "3", "d3-color": "3", "d3-contour": "4", "d3-delaunay": "6", "d3-dispatch": "3", "d3-drag": "3", "d3-dsv": "3", "d3-ease": "3", "d3-fetch": "3", "d3-force": "3", "d3-format": "3", "d3-geo": "3", "d3-hierarchy": "3", "d3-interpolate": "3", "d3-path": "3", "d3-polygon": "3", "d3-quadtree": "3", "d3-random": "3", "d3-scale": "4", "d3-scale-chromatic": "3", "d3-selection": "3", "d3-shape": "3", "d3-time": "3", "d3-time-format": "4", "d3-timer": "3", "d3-transition": "3", "d3-zoom": "3" } }, "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA=="],
+
+    "d3-array": ["d3-array@3.2.4", "", { "dependencies": { "internmap": "1 - 2" } }, "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg=="],
+
+    "d3-axis": ["d3-axis@3.0.0", "", {}, "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw=="],
+
+    "d3-brush": ["d3-brush@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", "d3-interpolate": "1 - 3", "d3-selection": "3", "d3-transition": "3" } }, "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ=="],
+
+    "d3-chord": ["d3-chord@3.0.1", "", { "dependencies": { "d3-path": "1 - 3" } }, "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g=="],
+
     "d3-color": ["d3-color@3.1.0", "", {}, "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA=="],
 
+    "d3-contour": ["d3-contour@4.0.2", "", { "dependencies": { "d3-array": "^3.2.0" } }, "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA=="],
+
+    "d3-delaunay": ["d3-delaunay@6.0.4", "", { "dependencies": { "delaunator": "5" } }, "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A=="],
+
     "d3-dispatch": ["d3-dispatch@3.0.1", "", {}, "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg=="],
 
     "d3-drag": ["d3-drag@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-selection": "3" } }, "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg=="],
 
+    "d3-dsv": ["d3-dsv@3.0.1", "", { "dependencies": { "commander": "7", "iconv-lite": "0.6", "rw": "1" }, "bin": { "csv2json": "bin/dsv2json.js", "csv2tsv": "bin/dsv2dsv.js", "dsv2dsv": "bin/dsv2dsv.js", "dsv2json": "bin/dsv2json.js", "json2csv": "bin/json2dsv.js", "json2dsv": "bin/json2dsv.js", "json2tsv": "bin/json2dsv.js", "tsv2csv": "bin/dsv2dsv.js", "tsv2json": "bin/dsv2json.js" } }, "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q=="],
+
     "d3-ease": ["d3-ease@3.0.1", "", {}, "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w=="],
 
+    "d3-fetch": ["d3-fetch@3.0.1", "", { "dependencies": { "d3-dsv": "1 - 3" } }, "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw=="],
+
+    "d3-force": ["d3-force@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-quadtree": "1 - 3", "d3-timer": "1 - 3" } }, "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg=="],
+
+    "d3-format": ["d3-format@3.1.2", "", {}, "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg=="],
+
+    "d3-geo": ["d3-geo@3.1.1", "", { "dependencies": { "d3-array": "2.5.0 - 3" } }, "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q=="],
+
+    "d3-hierarchy": ["d3-hierarchy@3.1.2", "", {}, "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA=="],
+
     "d3-interpolate": ["d3-interpolate@3.0.1", "", { "dependencies": { "d3-color": "1 - 3" } }, "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g=="],
 
+    "d3-path": ["d3-path@3.1.0", "", {}, "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ=="],
+
+    "d3-polygon": ["d3-polygon@3.0.1", "", {}, "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg=="],
+
+    "d3-quadtree": ["d3-quadtree@3.0.1", "", {}, "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw=="],
+
+    "d3-random": ["d3-random@3.0.1", "", {}, "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ=="],
+
+    "d3-sankey": ["d3-sankey@0.12.3", "", { "dependencies": { "d3-array": "1 - 2", "d3-shape": "^1.2.0" } }, "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ=="],
+
+    "d3-scale": ["d3-scale@4.0.2", "", { "dependencies": { "d3-array": "2.10.0 - 3", "d3-format": "1 - 3", "d3-interpolate": "1.2.0 - 3", "d3-time": "2.1.1 - 3", "d3-time-format": "2 - 4" } }, "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ=="],
+
+    "d3-scale-chromatic": ["d3-scale-chromatic@3.1.0", "", { "dependencies": { "d3-color": "1 - 3", "d3-interpolate": "1 - 3" } }, "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ=="],
+
     "d3-selection": ["d3-selection@3.0.0", "", {}, "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ=="],
 
+    "d3-shape": ["d3-shape@3.2.0", "", { "dependencies": { "d3-path": "^3.1.0" } }, "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA=="],
+
+    "d3-time": ["d3-time@3.1.0", "", { "dependencies": { "d3-array": "2 - 3" } }, "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q=="],
+
+    "d3-time-format": ["d3-time-format@4.1.0", "", { "dependencies": { "d3-time": "1 - 3" } }, "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg=="],
+
     "d3-timer": ["d3-timer@3.0.1", "", {}, "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA=="],
 
     "d3-transition": ["d3-transition@3.0.1", "", { "dependencies": { "d3-color": "1 - 3", "d3-dispatch": "1 - 3", "d3-ease": "1 - 3", "d3-interpolate": "1 - 3", "d3-timer": "1 - 3" }, "peerDependencies": { "d3-selection": "2 - 3" } }, "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w=="],
 
     "d3-zoom": ["d3-zoom@3.0.0", "", { "dependencies": { "d3-dispatch": "1 - 3", "d3-drag": "2 - 3", "d3-interpolate": "1 - 3", "d3-selection": "2 - 3", "d3-transition": "2 - 3" } }, "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw=="],
 
+    "dagre-d3-es": ["dagre-d3-es@7.0.14", "", { "dependencies": { "d3": "^7.9.0", "lodash-es": "^4.17.21" } }, "sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg=="],
+
     "data-uri-to-buffer": ["data-uri-to-buffer@4.0.1", "", {}, "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A=="],
 
     "data-urls": ["data-urls@5.0.0", "", { "dependencies": { "whatwg-mimetype": "^4.0.0", "whatwg-url": "^14.0.0" } }, "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg=="],
@@ -2088,6 +2162,8 @@
 
     "degenerator": ["degenerator@5.0.1", "", { "dependencies": { "ast-types": "^0.13.4", "escodegen": "^2.1.0", "esprima": "^4.0.1" } }, "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ=="],
 
+    "delaunator": ["delaunator@5.1.0", "", { "dependencies": { "robust-predicates": "^3.0.2" } }, "sha512-AGrQ4QSgssa1NGmWmLPqN5NY2KajF5MqxetNEO+o0n3ZwZZeTmt7bBnvzHWrmkZFxGgr4HdyFgelzgi06otLuQ=="],
+
     "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
 
     "denque": ["denque@2.1.0", "", {}, "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw=="],
@@ -2124,6 +2200,10 @@
 
     "docs": ["docs@workspace:apps/docs"],
 
+    "docx": ["docx@9.6.1", "", { "dependencies": { "@types/node": "^25.2.3", "hash.js": "^1.1.7", "jszip": "^3.10.1", "nanoid": "^5.1.3", "xml": "^1.0.1", "xml-js": "^1.6.8" } }, "sha512-ZJja9/KBUuFC109sCMzovoq2GR2wCG/AuxivjA+OHj/q0TEgJIm3S7yrlUxIy3B+bV8YDj/BiHfWyrRFmyWpDQ=="],
+
+    "docx-preview": ["docx-preview@0.3.7", "", { "dependencies": { "jszip": ">=3.0.0" } }, "sha512-Lav69CTA/IYZPJTsKH7oYeoZjyg96N0wEJMNslGJnZJ+dMUZK85Lt5ASC79yUlD48ecWjuv+rkcmFt6EVPV0Xg=="],
+
     "dom-accessibility-api": ["dom-accessibility-api@0.6.3", "", {}, "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w=="],
 
     "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="],
@@ -2416,12 +2496,16 @@
 
     "gtoken": ["gtoken@8.0.0", "", { "dependencies": { "gaxios": "^7.0.0", "jws": "^4.0.0" } }, "sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw=="],
 
+    "hachure-fill": ["hachure-fill@0.5.2", "", {}, "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg=="],
+
     "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
 
     "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
 
     "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
 
+    "hash.js": ["hash.js@1.1.7", "", { "dependencies": { "inherits": "^2.0.3", "minimalistic-assert": "^1.0.1" } }, "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA=="],
+
     "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
 
     "hast-util-from-parse5": ["hast-util-from-parse5@8.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "devlop": "^1.0.0", "hastscript": "^9.0.0", "property-information": "^7.0.0", "vfile": "^6.0.0", "vfile-location": "^5.0.0", "web-namespaces": "^2.0.0" } }, "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg=="],
@@ -2434,6 +2518,8 @@
 
     "hast-util-raw": ["hast-util-raw@9.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "hast-util-from-parse5": "^8.0.0", "hast-util-to-parse5": "^8.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "parse5": "^7.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0", "web-namespaces": "^2.0.0", "zwitch": "^2.0.0" } }, "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw=="],
 
+    "hast-util-sanitize": ["hast-util-sanitize@5.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "unist-util-position": "^5.0.0" } }, "sha512-3yTWghByc50aGS7JlGhk61SPenfE/p1oaFeNwkOOyrscaOkMGrcW9+Cy/QAIOBpZxP1yqDIzFMR0+Np0i0+usg=="],
+
     "hast-util-to-estree": ["hast-util-to-estree@3.1.3", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "estree-util-attach-comments": "^3.0.0", "estree-util-is-identifier-name": "^3.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-mdx-expression": "^2.0.0", "mdast-util-mdx-jsx": "^3.0.0", "mdast-util-mdxjs-esm": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "style-to-js": "^1.0.0", "unist-util-position": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w=="],
 
     "hast-util-to-html": ["hast-util-to-html@9.0.5", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-whitespace": "^3.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "stringify-entities": "^4.0.0", "zwitch": "^2.0.4" } }, "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw=="],
@@ -2512,6 +2598,8 @@
 
     "inquirer": ["inquirer@8.2.7", "", { "dependencies": { "@inquirer/external-editor": "^1.0.0", "ansi-escapes": "^4.2.1", "chalk": "^4.1.1", "cli-cursor": "^3.1.0", "cli-width": "^3.0.0", "figures": "^3.0.0", "lodash": "^4.17.21", "mute-stream": "0.0.8", "ora": "^5.4.1", "run-async": "^2.4.0", "rxjs": "^7.5.5", "string-width": "^4.1.0", "strip-ansi": "^6.0.0", "through": "^2.3.6", "wrap-ansi": "^6.0.1" } }, "sha512-UjOaSel/iddGZJ5xP/Eixh6dY1XghiBw4XK13rCCIJcJfyhhoul/7KhLLUGtebEj6GDYM6Vnx/mVsjx2L/mFIA=="],
 
+    "internmap": ["internmap@1.0.1", "", {}, "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw=="],
+
     "ioredis": ["ioredis@5.10.1", "", { "dependencies": { "@ioredis/commands": "1.5.1", "cluster-key-slot": "^1.1.0", "debug": "^4.3.4", "denque": "^2.1.0", "lodash.defaults": "^4.2.0", "lodash.isarguments": "^3.1.0", "redis-errors": "^1.2.0", "redis-parser": "^3.0.0", "standard-as-callback": "^2.1.0" } }, "sha512-HuEDBTI70aYdx1v6U97SbNx9F1+svQKBDo30o0b9fw055LMepzpOOd0Ccg9Q6tbqmBSJaMuY0fB7yw9/vjBYCA=="],
 
     "ip-address": ["ip-address@10.1.0", "", {}, "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q=="],
@@ -2610,6 +2698,8 @@
 
     "json-schema-to-ts": ["json-schema-to-ts@3.1.1", "", { "dependencies": { "@babel/runtime": "^7.18.3", "ts-algebra": "^2.0.0" } }, "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g=="],
 
+    "json-schema-to-typescript": ["json-schema-to-typescript@15.0.4", "", { "dependencies": { "@apidevtools/json-schema-ref-parser": "^11.5.5", "@types/json-schema": "^7.0.15", "@types/lodash": "^4.17.7", "is-glob": "^4.0.3", "js-yaml": "^4.1.0", "lodash": "^4.17.21", "minimist": "^1.2.8", "prettier": "^3.2.5", "tinyglobby": "^0.2.9" }, "bin": { "json2ts": "dist/src/cli.js" } }, "sha512-Su9oK8DR4xCmDsLlyvadkXzX6+GGXJpbhwoLtOGArAG61dvbW4YQmSEno2y66ahpIdmLMg6YUf/QHLgiwvkrHQ=="],
+
     "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
 
     "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
@@ -2626,14 +2716,22 @@
 
     "jwt-decode": ["jwt-decode@4.0.0", "", {}, "sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA=="],
 
+    "katex": ["katex@0.16.45", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-pQpZbdBu7wCTmQUh7ufPmLr0pFoObnGUoL/yhtwJDgmmQpbkg/0HSVti25Fu4rmd1oCR6NGWe9vqTWuWv3GcNA=="],
+
+    "khroma": ["khroma@2.1.0", "", {}, "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw=="],
+
     "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="],
 
     "kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="],
 
     "kysely": ["kysely@0.28.14", "", {}, "sha512-SU3lgh0rPvq7upc6vvdVrCsSMUG1h3ChvHVOY7wJ2fw4C9QEB7X3d5eyYEyULUX7UQtxZJtZXGuT6U2US72UYA=="],
 
+    "langium": ["langium@4.2.2", "", { "dependencies": { "@chevrotain/regexp-to-ast": "~12.0.0", "chevrotain": "~12.0.0", "chevrotain-allstar": "~0.4.1", "vscode-languageserver": "~9.0.1", "vscode-languageserver-textdocument": "~1.0.11", "vscode-uri": "~3.1.0" } }, "sha512-JUshTRAfHI4/MF9dH2WupvjSXyn8JBuUEWazB8ZVJUtXutT0doDlAv1XKbZ1Pb5sMexa8FF4CFBc0iiul7gbUQ=="],
+
     "langsmith": ["langsmith@0.3.87", "", { "dependencies": { "@types/uuid": "^10.0.0", "chalk": "^4.1.2", "console-table-printer": "^2.12.1", "p-queue": "^6.6.2", "semver": "^7.6.3", "uuid": "^10.0.0" }, "peerDependencies": { "@opentelemetry/api": "*", "@opentelemetry/exporter-trace-otlp-proto": "*", "@opentelemetry/sdk-trace-base": "*", "openai": "*" }, "optionalPeers": ["@opentelemetry/api", "@opentelemetry/exporter-trace-otlp-proto", "@opentelemetry/sdk-trace-base", "openai"] }, "sha512-XXR1+9INH8YX96FKWc5tie0QixWz6tOqAsAKfcJyPkE0xPep+NDz0IQLR32q4bn10QK3LqD2HN6T3n6z1YLW7Q=="],
 
+    "layout-base": ["layout-base@1.0.2", "", {}, "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg=="],
+
     "leac": ["leac@0.6.0", "", {}, "sha512-y+SqErxb8h7nE/fiEX07jsbuhrpO9lL8eca7/Y1nuWV2moNlXhyd59iDGcRf6moVyDMbmTNzL40SUyrFU/yDpg=="],
 
     "leven": ["leven@4.1.0", "", {}, "sha512-KZ9W9nWDT7rF7Dazg8xyLHGLrmpgq2nVNFUckhqdW3szVP6YhCpp/RAnpmVExA9JvrMynjwSLVrEj3AepHR6ew=="],
@@ -2686,6 +2784,8 @@
 
     "lodash": ["lodash@4.17.23", "", {}, "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w=="],
 
+    "lodash-es": ["lodash-es@4.18.1", "", {}, "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A=="],
+
     "lodash.camelcase": ["lodash.camelcase@4.3.0", "", {}, "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA=="],
 
     "lodash.defaults": ["lodash.defaults@4.2.0", "", {}, "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ=="],
@@ -2726,8 +2826,6 @@
 
     "lucide-react": ["lucide-react@0.511.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-VK5a2ydJ7xm8GvBeKLS9mu1pVK6ucef9780JVUjw6bAjJL/QXnd4Y0p7SPeOUMC27YhzNCZvm5d/QX0Tp3rc0w=="],
 
-    "luxon": ["luxon@3.7.2", "", {}, "sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew=="],
-
     "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="],
 
     "magicast": ["magicast@0.3.5", "", { "dependencies": { "@babel/parser": "^7.25.4", "@babel/types": "^7.25.4", "source-map-js": "^1.2.0" } }, "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ=="],
@@ -2794,6 +2892,8 @@
 
     "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
 
+    "mermaid": ["mermaid@11.14.0", "", { "dependencies": { "@braintree/sanitize-url": "^7.1.1", "@iconify/utils": "^3.0.2", "@mermaid-js/parser": "^1.1.0", "@types/d3": "^7.4.3", "@upsetjs/venn.js": "^2.0.0", "cytoscape": "^3.33.1", "cytoscape-cose-bilkent": "^4.1.0", "cytoscape-fcose": "^2.2.0", "d3": "^7.9.0", "d3-sankey": "^0.12.3", "dagre-d3-es": "7.0.14", "dayjs": "^1.11.19", "dompurify": "^3.3.1", "katex": "^0.16.25", "khroma": "^2.1.0", "lodash-es": "^4.17.23", "marked": "^16.3.0", "roughjs": "^4.6.6", "stylis": "^4.3.6", "ts-dedent": "^2.2.0", "uuid": "^11.1.0" } }, "sha512-GSGloRsBs+JINmmhl0JDwjpuezCsHB4WGI4NASHxL3fHo3o/BRXTxhDLKnln8/Q0lRFRyDdEjmk1/d5Sn1Xz8g=="],
+
     "meshoptimizer": ["meshoptimizer@0.18.1", "", {}, "sha512-ZhoIoL7TNV4s5B6+rx5mC//fw8/POGyNxS/DZyCJeiZ12ScLfVwRE/GfsxwiTkMYYD5DmK2/JXnEVXqL4rF+Sw=="],
 
     "methods": ["methods@1.1.2", "", {}, "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w=="],
@@ -2918,10 +3018,6 @@
 
     "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
 
-    "msgpackr": ["msgpackr@1.11.5", "", { "optionalDependencies": { "msgpackr-extract": "^3.0.2" } }, "sha512-UjkUHN0yqp9RWKy0Lplhh+wlpdt9oQBYgULZOiFhV3VclSF1JnSQWZ5r9gORQlNYaUKQoR8itv7g7z1xDDuACA=="],
-
-    "msgpackr-extract": ["msgpackr-extract@3.0.3", "", { "dependencies": { "node-gyp-build-optional-packages": "5.2.2" }, "optionalDependencies": { "@msgpackr-extract/msgpackr-extract-darwin-arm64": "3.0.3", "@msgpackr-extract/msgpackr-extract-darwin-x64": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-arm": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-arm64": "3.0.3", "@msgpackr-extract/msgpackr-extract-linux-x64": "3.0.3", "@msgpackr-extract/msgpackr-extract-win32-x64": "3.0.3" }, "bin": { "download-msgpackr-prebuilds": "bin/download-prebuilds.js" } }, "sha512-P0efT1C9jIdVRefqjzOQ9Xml57zpOXnIuS+csaB4MdZbTdmGDLo8XhzBG1N7aO11gKDDkJvBLULeFTo46wwreA=="],
-
     "mustache": ["mustache@4.2.0", "", { "bin": { "mustache": "bin/mustache" } }, "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ=="],
 
     "mute-stream": ["mute-stream@0.0.8", "", {}, "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA=="],
@@ -2962,8 +3058,6 @@
 
     "node-abi": ["node-abi@3.89.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-6u9UwL0HlAl21+agMN3YAMXcKByMqwGx+pq+P76vii5f7hTPtKDp08/H9py6DY+cfDw7kQNTGEj/rly3IgbNQA=="],
 
-    "node-abort-controller": ["node-abort-controller@3.1.1", "", {}, "sha512-AGK2yQKIjRuqnc6VkX2Xj5d+QW8xZ87pa1UK6yA6ouUyuxfHuMP6umE5QK7UmTeOAymo+Zx1Fxiuw9rVx8taHQ=="],
-
     "node-domexception": ["node-domexception@1.0.0", "", {}, "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ=="],
 
     "node-ensure": ["node-ensure@0.0.0", "", {}, "sha512-DRI60hzo2oKN1ma0ckc6nQWlHU69RH6xN0sjQTjMpChPfTYvKZdcQFfdYK2RWbJcKyUizSIy/l8OTGxMAM1QDw=="],
@@ -2974,8 +3068,6 @@
 
     "node-gyp-build": ["node-gyp-build@4.8.4", "", { "bin": { "node-gyp-build": "bin.js", "node-gyp-build-optional": "optional.js", "node-gyp-build-test": "build-test.js" } }, "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ=="],
 
-    "node-gyp-build-optional-packages": ["node-gyp-build-optional-packages@5.2.2", "", { "dependencies": { "detect-libc": "^2.0.1" }, "bin": { "node-gyp-build-optional-packages": "bin.js", "node-gyp-build-optional-packages-optional": "optional.js", "node-gyp-build-optional-packages-test": "build-test.js" } }, "sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw=="],
-
     "node-int64": ["node-int64@0.4.0", "", {}, "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw=="],
 
     "node-readable-to-web-readable-stream": ["node-readable-to-web-readable-stream@0.4.2", "", {}, "sha512-/cMZNI34v//jUTrI+UIo4ieHAB5EZRY/+7OmXZgBxaWBMcW2tGdceIw06RFxWxrKZ5Jp3sI2i5TsRo+CBhtVLQ=="],
@@ -3060,6 +3152,8 @@
 
     "package-json-from-dist": ["package-json-from-dist@1.0.1", "", {}, "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="],
 
+    "package-manager-detector": ["package-manager-detector@1.6.0", "", {}, "sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA=="],
+
     "pako": ["pako@1.0.11", "", {}, "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw=="],
 
     "papaparse": ["papaparse@5.5.3", "", {}, "sha512-5QvjGxYVjxO59MGU2lHVYpRWBBtKHnlIAcSe1uNFCkkptUh63NFRj0FJQm7nR67puEruUci/ZkjmEFrjCAyP4A=="],
@@ -3082,6 +3176,8 @@
 
     "patchright-core": ["patchright-core@1.58.2", "", { "bin": { "patchright-core": "cli.js" } }, "sha512-f3r0u6as+4nd0Vmr4ndH/zwijMHj7ECxelSa5iMeIJPxtLOwbo22LQPC1qjZZtSIhAVzUDStx4nw/BW3MqhJIQ=="],
 
+    "path-data-parser": ["path-data-parser@0.1.0", "", {}, "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w=="],
+
     "path-expression-matcher": ["path-expression-matcher@1.2.0", "", {}, "sha512-DwmPWeFn+tq7TiyJ2CxezCAirXjFxvaiD03npak3cRjlP9+OjTmSy1EpIrEbh+l6JgUundniloMLDQ/6VTdhLQ=="],
 
     "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="],
@@ -3138,6 +3234,10 @@
 
     "playwright-core": ["playwright-core@1.58.2", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-yZkEtftgwS8CsfYo7nm0KE8jsvm6i/PTgVtB8DL726wNf6H2IMsDuxCpJj59KDaxCtSnrWan2AeDqM7JBaultg=="],
 
+    "points-on-curve": ["points-on-curve@0.2.0", "", {}, "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A=="],
+
+    "points-on-path": ["points-on-path@0.2.1", "", { "dependencies": { "path-data-parser": "0.1.0", "points-on-curve": "0.2.0" } }, "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g=="],
+
     "popper.js": ["popper.js@1.16.1", "", {}, "sha512-Wb4p1J4zyFTbM+u6WuO4XstYx4Ky9Cewe4DWrel7B0w6VVICvPwdOpotjzcf6eD8TsckVnIMNONQyPIUFOUbCQ=="],
 
     "postcss": ["postcss@8.5.8", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg=="],
@@ -3244,8 +3344,6 @@
 
     "react-joyride": ["react-joyride@2.9.3", "", { "dependencies": { "@gilbarbara/deep-equal": "^0.3.1", "deep-diff": "^1.0.2", "deepmerge": "^4.3.1", "is-lite": "^1.2.1", "react-floater": "^0.7.9", "react-innertext": "^1.1.5", "react-is": "^16.13.1", "scroll": "^3.0.1", "scrollparent": "^2.1.0", "tree-changes": "^0.11.2", "type-fest": "^4.27.0" }, "peerDependencies": { "react": "15 - 18", "react-dom": "15 - 18" } }, "sha512-1+Mg34XK5zaqJ63eeBhqdbk7dlGCFp36FXwsEvgpjqrtyywX2C6h9vr3jgxP0bGHCw8Ilsp/nRDzNVq6HJ3rNw=="],
 
-    "react-markdown": ["react-markdown@10.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "hast-util-to-jsx-runtime": "^2.0.0", "html-url-attributes": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" }, "peerDependencies": { "@types/react": ">=18", "react": ">=18" } }, "sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ=="],
-
     "react-medium-image-zoom": ["react-medium-image-zoom@5.4.1", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-DD2iZYaCfAwiQGR8AN62r/cDJYoXhezlYJc5HY4TzBUGuGge43CptG0f7m0PEIM72aN6GfpjohvY1yYdtCJB7g=="],
 
     "react-promise-suspense": ["react-promise-suspense@0.3.4", "", { "dependencies": { "fast-deep-equal": "^2.0.1" } }, "sha512-I42jl7L3Ze6kZaq+7zXWSunBa3b1on5yfvUW6Eo/3fFOj6dZ5Bqmcd264nJbTK/gn1HjjILAjSwnZbV4RpSaNQ=="],
@@ -3300,10 +3398,14 @@
 
     "rehype-autolink-headings": ["rehype-autolink-headings@7.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "hast-util-heading-rank": "^3.0.0", "hast-util-is-element": "^3.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-rItO/pSdvnvsP4QRB1pmPiNHUskikqtPojZKJPPPAVx9Hj8i8TwMBhofrrAYRhYOOBZH9tgmG5lPqDLuIWPWmw=="],
 
+    "rehype-harden": ["rehype-harden@1.1.8", "", { "dependencies": { "unist-util-visit": "^5.0.0" } }, "sha512-Qn7vR1xrf6fZCrkm9TDWi/AB4ylrHy+jqsNm1EHOAmbARYA6gsnVJBq/sdBh6kmT4NEZxH5vgIjrscefJAOXcw=="],
+
     "rehype-raw": ["rehype-raw@7.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-raw": "^9.0.0", "vfile": "^6.0.0" } }, "sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww=="],
 
     "rehype-recma": ["rehype-recma@1.0.0", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "hast-util-to-estree": "^3.0.0" } }, "sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw=="],
 
+    "rehype-sanitize": ["rehype-sanitize@6.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-sanitize": "^5.0.0" } }, "sha512-CsnhKNsyI8Tub6L4sm5ZFsme4puGfc6pYylvXo1AeqaGbjOYyzNv3qZPwvs0oMJ39eryyeOdmxwUIo94IpEhqg=="],
+
     "rehype-slug": ["rehype-slug@6.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "github-slugger": "^2.0.0", "hast-util-heading-rank": "^3.0.0", "hast-util-to-string": "^3.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-lWyvf/jwu+oS5+hL5eClVd3hNdmwM1kAC0BUvEGD19pajQMIzcNUd/k9GsfQ+FfECvX+JE+e9/btsKH0EjJT6A=="],
 
     "remark": ["remark@15.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "remark-parse": "^11.0.0", "remark-stringify": "^11.0.0", "unified": "^11.0.0" } }, "sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A=="],
@@ -3320,6 +3422,8 @@
 
     "remark-stringify": ["remark-stringify@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-to-markdown": "^2.0.0", "unified": "^11.0.0" } }, "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw=="],
 
+    "remend": ["remend@1.3.0", "", {}, "sha512-iIhggPkhW3hFImKtB10w0dz4EZbs28mV/dmbcYVonWEJ6UGHHpP+bFZnTh6GNWJONg5m+U56JrL+8IxZRdgWjw=="],
+
     "require-directory": ["require-directory@2.1.1", "", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="],
 
     "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
@@ -3342,10 +3446,14 @@
 
     "rfdc": ["rfdc@1.4.1", "", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="],
 
+    "robust-predicates": ["robust-predicates@3.0.3", "", {}, "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA=="],
+
     "rollup": ["rollup@4.60.0", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.60.0", "@rollup/rollup-android-arm64": "4.60.0", "@rollup/rollup-darwin-arm64": "4.60.0", "@rollup/rollup-darwin-x64": "4.60.0", "@rollup/rollup-freebsd-arm64": "4.60.0", "@rollup/rollup-freebsd-x64": "4.60.0", "@rollup/rollup-linux-arm-gnueabihf": "4.60.0", "@rollup/rollup-linux-arm-musleabihf": "4.60.0", "@rollup/rollup-linux-arm64-gnu": "4.60.0", "@rollup/rollup-linux-arm64-musl": "4.60.0", "@rollup/rollup-linux-loong64-gnu": "4.60.0", "@rollup/rollup-linux-loong64-musl": "4.60.0", "@rollup/rollup-linux-ppc64-gnu": "4.60.0", "@rollup/rollup-linux-ppc64-musl": "4.60.0", "@rollup/rollup-linux-riscv64-gnu": "4.60.0", "@rollup/rollup-linux-riscv64-musl": "4.60.0", "@rollup/rollup-linux-s390x-gnu": "4.60.0", "@rollup/rollup-linux-x64-gnu": "4.60.0", "@rollup/rollup-linux-x64-musl": "4.60.0", "@rollup/rollup-openbsd-x64": "4.60.0", "@rollup/rollup-openharmony-arm64": "4.60.0", "@rollup/rollup-win32-arm64-msvc": "4.60.0", "@rollup/rollup-win32-ia32-msvc": "4.60.0", "@rollup/rollup-win32-x64-gnu": "4.60.0", "@rollup/rollup-win32-x64-msvc": "4.60.0", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-yqjxruMGBQJ2gG4HtjZtAfXArHomazDHoFwFFmZZl0r7Pdo7qCIXKqKHZc8yeoMgzJJ+pO6pEEHa+V7uzWlrAQ=="],
 
     "rou3": ["rou3@0.5.1", "", {}, "sha512-OXMmJ3zRk2xeXFGfA3K+EOPHC5u7RDFG7lIOx0X1pdnhUkI8MdVrbV+sNsD80ElpUZ+MRHdyxPnFthq9VHs8uQ=="],
 
+    "roughjs": ["roughjs@4.6.6", "", { "dependencies": { "hachure-fill": "^0.5.2", "path-data-parser": "^0.1.0", "points-on-curve": "^0.2.0", "points-on-path": "^0.2.1" } }, "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ=="],
+
     "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="],
 
     "rrweb-cssom": ["rrweb-cssom@0.8.0", "", {}, "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw=="],
@@ -3358,6 +3466,8 @@
 
     "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
 
+    "rw": ["rw@1.3.3", "", {}, "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ=="],
+
     "rxjs": ["rxjs@7.8.2", "", { "dependencies": { "tslib": "^2.1.0" } }, "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA=="],
 
     "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
@@ -3500,6 +3610,8 @@
 
     "stdin-discarder": ["stdin-discarder@0.2.2", "", {}, "sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ=="],
 
+    "streamdown": ["streamdown@2.5.0", "", { "dependencies": { "clsx": "^2.1.1", "hast-util-to-jsx-runtime": "^2.3.6", "html-url-attributes": "^3.0.1", "marked": "^17.0.1", "mermaid": "^11.12.2", "rehype-harden": "^1.1.8", "rehype-raw": "^7.0.0", "rehype-sanitize": "^6.0.0", "remark-gfm": "^4.0.1", "remark-parse": "^11.0.0", "remark-rehype": "^11.1.2", "remend": "1.3.0", "tailwind-merge": "^3.4.0", "unified": "^11.0.5", "unist-util-visit": "^5.0.0", "unist-util-visit-parents": "^6.0.0" }, "peerDependencies": { "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" } }, "sha512-/tTnURfIOxZK/pqJAxsfCvETG/XCJHoWnk3jq9xLcuz6CSpnjjuxSRBTTL4PKGhxiZQf0lqPxGhImdpwcZ2XwA=="],
+
     "streamx": ["streamx@2.25.0", "", { "dependencies": { "events-universal": "^1.0.0", "fast-fifo": "^1.3.2", "text-decoder": "^1.1.0" } }, "sha512-0nQuG6jf1w+wddNEEXCF4nTg3LtufWINB5eFEN+5TNZW7KWJp6x87+JFL43vaAUPyCfH1wID+mNVyW6OHtFamg=="],
 
     "string-argv": ["string-argv@0.3.2", "", {}, "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q=="],
@@ -3544,6 +3656,8 @@
 
     "styled-jsx": ["styled-jsx@5.1.6", "", { "dependencies": { "client-only": "0.0.1" }, "peerDependencies": { "react": ">= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0" } }, "sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA=="],
 
+    "stylis": ["stylis@4.3.6", "", {}, "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ=="],
+
     "sucrase": ["sucrase@3.35.1", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.2", "commander": "^4.0.0", "lines-and-columns": "^1.1.6", "mz": "^2.7.0", "pirates": "^4.0.1", "tinyglobby": "^0.2.11", "ts-interface-checker": "^0.1.9" }, "bin": { "sucrase": "bin/sucrase", "sucrase-node": "bin/sucrase-node" } }, "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw=="],
 
     "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
@@ -3628,6 +3742,8 @@
 
     "ts-algebra": ["ts-algebra@2.0.0", "", {}, "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw=="],
 
+    "ts-dedent": ["ts-dedent@2.2.0", "", {}, "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ=="],
+
     "ts-interface-checker": ["ts-interface-checker@0.1.13", "", {}, "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA=="],
 
     "tsafe": ["tsafe@1.8.12", "", {}, "sha512-nFRqW0ttu/2o6XTXsHiVZWJBCOaxhVqZLg7dgs3coZNsCMPXPfwz+zPHAQA+70fNnVJLAPg1EgGIqK9Q84tvAw=="],
@@ -3742,10 +3858,18 @@
 
     "vitest": ["vitest@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/expect": "3.2.4", "@vitest/mocker": "3.2.4", "@vitest/pretty-format": "^3.2.4", "@vitest/runner": "3.2.4", "@vitest/snapshot": "3.2.4", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "debug": "^4.4.1", "expect-type": "^1.2.1", "magic-string": "^0.30.17", "pathe": "^2.0.3", "picomatch": "^4.0.2", "std-env": "^3.9.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.14", "tinypool": "^1.1.1", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", "vite-node": "3.2.4", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.2.4", "@vitest/ui": "3.2.4", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A=="],
 
+    "vscode-jsonrpc": ["vscode-jsonrpc@8.2.0", "", {}, "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA=="],
+
+    "vscode-languageserver": ["vscode-languageserver@9.0.1", "", { "dependencies": { "vscode-languageserver-protocol": "3.17.5" }, "bin": { "installServerIntoExtension": "bin/installServerIntoExtension" } }, "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g=="],
+
+    "vscode-languageserver-protocol": ["vscode-languageserver-protocol@3.17.5", "", { "dependencies": { "vscode-jsonrpc": "8.2.0", "vscode-languageserver-types": "3.17.5" } }, "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg=="],
+
     "vscode-languageserver-textdocument": ["vscode-languageserver-textdocument@1.0.12", "", {}, "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA=="],
 
     "vscode-languageserver-types": ["vscode-languageserver-types@3.17.5", "", {}, "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg=="],
 
+    "vscode-uri": ["vscode-uri@3.1.0", "", {}, "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ=="],
+
     "w3c-xmlserializer": ["w3c-xmlserializer@5.0.0", "", { "dependencies": { "xml-name-validator": "^5.0.0" } }, "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA=="],
 
     "wcwidth": ["wcwidth@1.0.1", "", { "dependencies": { "defaults": "^1.0.3" } }, "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg=="],
@@ -3834,6 +3958,10 @@
 
     "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
 
+    "@antfu/install-pkg/tinyexec": ["tinyexec@1.0.4", "", {}, "sha512-u9r3uZC0bdpGOXtlxUIdwf9pkmvhqJdrVCH9fapQtgy/OeTTMZ1nqH7agtvEfmGui6e1XxjcdrlxvxJvc3sMqw=="],
+
+    "@apidevtools/json-schema-ref-parser/js-yaml": ["js-yaml@4.1.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA=="],
+
     "@asamuzakjp/css-color/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="],
 
     "@authenio/xml-encryption/xpath": ["xpath@0.0.32", "", {}, "sha512-rxMJhSIoiO8vXcWvSifKqhvV96GjiD5wYb8/QHdoRyQvraTpp4IEv944nhGausZZ3u7dhQXteZuZbaqfpB7uYw=="],
@@ -4576,8 +4704,6 @@
 
     "body-parser/iconv-lite": ["iconv-lite@0.7.1", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-2Tth85cXwGFHfvRgZWszZSvdo+0Xsqmw8k8ZwxScfcBneNUraK+dxRxRm24nszx80Y0TVio8kKLt5sLE7ZCLlw=="],
 
-    "bullmq/ioredis": ["ioredis@5.9.3", "", { "dependencies": { "@ioredis/commands": "1.5.0", "cluster-key-slot": "^1.1.0", "debug": "^4.3.4", "denque": "^2.1.0", "lodash.defaults": "^4.2.0", "lodash.isarguments": "^3.1.0", "redis-errors": "^1.2.0", "redis-parser": "^3.0.0", "standard-as-callback": "^2.1.0" } }, "sha512-VI5tMCdeoxZWU5vjHWsiE/Su76JGhBvWF1MJnV9ZtGltHk9BmD48oDq8Tj8haZ85aceXZMxLNDQZRVo5QKNgXA=="],
-
     "c12/chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
 
     "c12/confbox": ["confbox@0.2.4", "", {}, "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ=="],
@@ -4606,6 +4732,16 @@
 
     "cross-spawn/which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
 
+    "cytoscape-fcose/cose-base": ["cose-base@2.2.0", "", { "dependencies": { "layout-base": "^2.0.0" } }, "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g=="],
+
+    "d3-dsv/commander": ["commander@7.2.0", "", {}, "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw=="],
+
+    "d3-sankey/d3-array": ["d3-array@2.12.1", "", { "dependencies": { "internmap": "^1.0.0" } }, "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ=="],
+
+    "d3-sankey/d3-shape": ["d3-shape@1.3.7", "", { "dependencies": { "d3-path": "1" } }, "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw=="],
+
+    "docx/@types/node": ["@types/node@25.5.2", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg=="],
+
     "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
 
     "e2b/glob": ["glob@11.1.0", "", { "dependencies": { "foreground-child": "^3.3.1", "jackspeak": "^4.1.1", "minimatch": "^10.1.1", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw=="],
@@ -4686,6 +4822,10 @@
 
     "jaeger-client/uuid": ["uuid@8.3.2", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="],
 
+    "json-schema-to-typescript/js-yaml": ["js-yaml@4.1.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA=="],
+
+    "katex/commander": ["commander@8.3.0", "", {}, "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="],
+
     "langsmith/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
 
     "langsmith/uuid": ["uuid@10.0.0", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ=="],
@@ -4714,6 +4854,8 @@
 
     "mdast-util-find-and-replace/escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="],
 
+    "mermaid/marked": ["marked@16.4.2", "", { "bin": { "marked": "bin/marked.js" } }, "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA=="],
+
     "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="],
 
     "neo4j-driver-bolt-connection/string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
@@ -5188,8 +5330,6 @@
 
     "bl/readable-stream/string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
 
-    "bullmq/ioredis/@ioredis/commands": ["@ioredis/commands@1.5.0", "", {}, "sha512-eUgLqrMf8nJkZxT24JvVRrQya1vZkQh8BBeYNwGDqa5I0VUi8ACx7uFvAaLxintokpTenkK6DASvo/bvNbBGow=="],
-
     "c12/chokidar/readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
 
     "cheerio/htmlparser2/entities": ["entities@7.0.1", "", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
@@ -5208,6 +5348,12 @@
 
     "critters/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
 
+    "cytoscape-fcose/cose-base/layout-base": ["layout-base@2.0.1", "", {}, "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg=="],
+
+    "d3-sankey/d3-shape/d3-path": ["d3-path@1.0.9", "", {}, "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg=="],
+
+    "docx/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+
     "engine.io/@types/node/undici-types": ["undici-types@7.10.0", "", {}, "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="],
 
     "fetch-cookie/tough-cookie/tldts": ["tldts@7.0.27", "", { "dependencies": { "tldts-core": "^7.0.27" }, "bin": { "tldts": "bin/cli.js" } }, "sha512-I4FZcVFcqCRuT0ph6dCDpPuO4Xgzvh+spkcTr1gK7peIvxWauoloVO0vuy1FQnijT63ss6AsHB6+OIM4aXHbPg=="],
diff --git a/docker-compose.local.yml b/docker-compose.local.yml
index 8b874acee88..335fb0c33ab 100644
--- a/docker-compose.local.yml
+++ b/docker-compose.local.yml
@@ -67,36 +67,6 @@ services:
       retries: 3
       start_period: 10s
 
-  sim-worker:
-    build:
-      context: .
-      dockerfile: docker/app.Dockerfile
-    command: ['bun', 'apps/sim/worker/index.ts']
-    restart: unless-stopped
-    deploy:
-      resources:
-        limits:
-          memory: 4G
-    environment:
-      - NODE_ENV=development
-      - DATABASE_URL=postgresql://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@db:5432/${POSTGRES_DB:-simstudio}
-      - REDIS_URL=${REDIS_URL:-}
-      - ENCRYPTION_KEY=${ENCRYPTION_KEY:-dev-encryption-key-at-least-32-chars}
-      - API_ENCRYPTION_KEY=${API_ENCRYPTION_KEY:-}
-      - INTERNAL_API_SECRET=${INTERNAL_API_SECRET:-dev-internal-api-secret-min-32-chars}
-      - WORKER_PORT=3001
-    depends_on:
-      db:
-        condition: service_healthy
-      migrations:
-        condition: service_completed_successfully
-    healthcheck:
-      test: ['CMD', 'curl', '-fsS', 'http://127.0.0.1:3001/health/live']
-      interval: 90s
-      timeout: 5s
-      retries: 3
-      start_period: 10s
-
   migrations:
     build:
       context: .
diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml
index e7000f06883..cbb667b1c55 100644
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -24,8 +24,6 @@ services:
       - SOCKET_SERVER_URL=${SOCKET_SERVER_URL:-http://realtime:3002}
       - NEXT_PUBLIC_SOCKET_URL=${NEXT_PUBLIC_SOCKET_URL:-http://localhost:3002}
       - ADMISSION_GATE_MAX_INFLIGHT=${ADMISSION_GATE_MAX_INFLIGHT:-500}
-      - DISPATCH_MAX_QUEUE_PER_WORKSPACE=${DISPATCH_MAX_QUEUE_PER_WORKSPACE:-1000}
-      - DISPATCH_MAX_QUEUE_GLOBAL=${DISPATCH_MAX_QUEUE_GLOBAL:-50000}
     depends_on:
       db:
         condition: service_healthy
@@ -40,43 +38,6 @@ services:
       retries: 3
       start_period: 10s
 
-  sim-worker:
-    image: ghcr.io/simstudioai/simstudio:latest
-    command: ['bun', 'apps/sim/worker/index.ts']
-    restart: unless-stopped
-    deploy:
-      resources:
-        limits:
-          memory: 4G
-    environment:
-      - NODE_ENV=production
-      - DATABASE_URL=postgresql://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@db:5432/${POSTGRES_DB:-simstudio}
-      - REDIS_URL=${REDIS_URL:-}
-      - ENCRYPTION_KEY=${ENCRYPTION_KEY}
-      - API_ENCRYPTION_KEY=${API_ENCRYPTION_KEY:-}
-      - INTERNAL_API_SECRET=${INTERNAL_API_SECRET}
-      - WORKER_PORT=${WORKER_PORT:-3001}
-      - WORKER_CONCURRENCY_WORKFLOW=${WORKER_CONCURRENCY_WORKFLOW:-50}
-      - WORKER_CONCURRENCY_WEBHOOK=${WORKER_CONCURRENCY_WEBHOOK:-30}
-      - WORKER_CONCURRENCY_SCHEDULE=${WORKER_CONCURRENCY_SCHEDULE:-20}
-      - WORKER_CONCURRENCY_MOTHERSHIP_JOB=${WORKER_CONCURRENCY_MOTHERSHIP_JOB:-10}
-      - WORKER_CONCURRENCY_CONNECTOR_SYNC=${WORKER_CONCURRENCY_CONNECTOR_SYNC:-5}
-      - WORKER_CONCURRENCY_DOCUMENT_PROCESSING=${WORKER_CONCURRENCY_DOCUMENT_PROCESSING:-20}
-      - WORKER_CONCURRENCY_NOTIFICATION_DELIVERY=${WORKER_CONCURRENCY_NOTIFICATION_DELIVERY:-10}
-      - DISPATCH_MAX_QUEUE_PER_WORKSPACE=${DISPATCH_MAX_QUEUE_PER_WORKSPACE:-1000}
-      - DISPATCH_MAX_QUEUE_GLOBAL=${DISPATCH_MAX_QUEUE_GLOBAL:-50000}
-    depends_on:
-      db:
-        condition: service_healthy
-      migrations:
-        condition: service_completed_successfully
-    healthcheck:
-      test: ['CMD', 'curl', '-fsS', 'http://127.0.0.1:${WORKER_PORT:-3001}/health/live']
-      interval: 90s
-      timeout: 5s
-      retries: 3
-      start_period: 10s
-
   realtime:
     image: ghcr.io/simstudioai/realtime:latest
     restart: unless-stopped
diff --git a/docker/app.Dockerfile b/docker/app.Dockerfile
index 07641931f04..7fe2507fc92 100644
--- a/docker/app.Dockerfile
+++ b/docker/app.Dockerfile
@@ -104,11 +104,8 @@ COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/public ./apps/sim/public
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/.next/standalone ./
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/.next/static ./apps/sim/.next/static
 
-# Copy the full dependency tree and app source so the BullMQ worker can run from source.
-# The standalone server continues to use server.js; the worker uses bun on worker/index.ts.
-COPY --from=deps --chown=nextjs:nodejs /app/node_modules ./node_modules
-COPY --from=builder --chown=nextjs:nodejs /app/apps/sim ./apps/sim
-COPY --from=builder --chown=nextjs:nodejs /app/packages ./packages
+# Copy blog/author content for runtime filesystem reads (not part of the JS bundle)
+COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/content ./apps/sim/content
 
 # Copy isolated-vm native module (compiled for Node.js in deps stage)
 COPY --from=deps --chown=nextjs:nodejs /app/node_modules/isolated-vm ./node_modules/isolated-vm
@@ -116,8 +113,9 @@ COPY --from=deps --chown=nextjs:nodejs /app/node_modules/isolated-vm ./node_modu
 # Copy the isolated-vm worker script
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/lib/execution/isolated-vm-worker.cjs ./apps/sim/lib/execution/isolated-vm-worker.cjs
 
-# Copy the bundled PPTX worker artifact
+# Copy the bundled worker artifacts
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/dist/pptx-worker.cjs ./apps/sim/dist/pptx-worker.cjs
+COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/dist/doc-worker.cjs ./apps/sim/dist/doc-worker.cjs
 
 # Guardrails setup with pip caching
 COPY --from=builder --chown=nextjs:nodejs /app/apps/sim/lib/guardrails/requirements.txt ./apps/sim/lib/guardrails/requirements.txt
diff --git a/helm/sim/README.md b/helm/sim/README.md
index 3507f543495..70d5facb8ae 100644
--- a/helm/sim/README.md
+++ b/helm/sim/README.md
@@ -709,16 +709,9 @@ kubectl create secret generic my-postgresql-secret \
 
 See `examples/values-existing-secret.yaml` for more details.
 
-### Worker and Redis
+### Redis
 
-The Helm chart enables the BullMQ worker by default so the deployment topology matches Docker Compose. If `REDIS_URL` is not configured, the worker pod will still start but remain idle and do no queue processing. This is expected.
-
-Queue-backed API, webhook, and schedule execution requires Redis. Installs without Redis continue to use the inline execution path. If you do not want the worker pod at all, set:
-
-```yaml
-worker:
-  enabled: false
-```
+Redis is optional. When configured via `REDIS_URL`, it enables features like copilot chat stream coordination and caching. Without Redis, the application uses in-memory fallbacks.
 
 ### External Secrets Parameters
 
diff --git a/helm/sim/templates/_helpers.tpl b/helm/sim/templates/_helpers.tpl
index 915df7cf618..e1bee304913 100644
--- a/helm/sim/templates/_helpers.tpl
+++ b/helm/sim/templates/_helpers.tpl
@@ -117,22 +117,6 @@ Ollama selector labels
 app.kubernetes.io/component: ollama
 {{- end }}
 
-{{/*
-Worker specific labels
-*/}}
-{{- define "sim.worker.labels" -}}
-{{ include "sim.labels" . }}
-app.kubernetes.io/component: worker
-{{- end }}
-
-{{/*
-Worker selector labels
-*/}}
-{{- define "sim.worker.selectorLabels" -}}
-{{ include "sim.selectorLabels" . }}
-app.kubernetes.io/component: worker
-{{- end }}
-
 {{/*
 Migrations specific labels
 */}}
diff --git a/helm/sim/templates/deployment-worker.yaml b/helm/sim/templates/deployment-worker.yaml
deleted file mode 100644
index 75fa6e88c17..00000000000
--- a/helm/sim/templates/deployment-worker.yaml
+++ /dev/null
@@ -1,101 +0,0 @@
-{{- if .Values.worker.enabled }}
-{{- include "sim.validateSecrets" . }}
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: {{ include "sim.fullname" . }}-worker
-  namespace: {{ .Release.Namespace }}
-  labels:
-    {{- include "sim.worker.labels" . | nindent 4 }}
-spec:
-  replicas: {{ .Values.worker.replicaCount }}
-  selector:
-    matchLabels:
-      {{- include "sim.worker.selectorLabels" . | nindent 6 }}
-  template:
-    metadata:
-      annotations:
-        {{- with .Values.podAnnotations }}
-        {{- toYaml . | nindent 8 }}
-        {{- end }}
-      labels:
-        {{- include "sim.worker.selectorLabels" . | nindent 8 }}
-        {{- with .Values.podLabels }}
-        {{- toYaml . | nindent 8 }}
-        {{- end }}
-    spec:
-      {{- with .Values.global.imagePullSecrets }}
-      imagePullSecrets:
-        {{- toYaml . | nindent 8 }}
-      {{- end }}
-      serviceAccountName: {{ include "sim.serviceAccountName" . }}
-      {{- include "sim.podSecurityContext" .Values.worker | nindent 6 }}
-      {{- include "sim.nodeSelector" .Values.worker | nindent 6 }}
-      {{- include "sim.tolerations" .Values | nindent 6 }}
-      {{- include "sim.affinity" .Values | nindent 6 }}
-      containers:
-        - name: worker
-          image: {{ include "sim.image" (dict "context" . "image" .Values.worker.image) }}
-          imagePullPolicy: {{ .Values.worker.image.pullPolicy }}
-          command: ["bun", "apps/sim/worker/index.ts"]
-          ports:
-            - name: health
-              containerPort: {{ .Values.worker.healthPort }}
-              protocol: TCP
-          env:
-            - name: DATABASE_URL
-              value: {{ include "sim.databaseUrl" . | quote }}
-            {{- if .Values.app.env.REDIS_URL }}
-            - name: REDIS_URL
-              value: {{ .Values.app.env.REDIS_URL | quote }}
-            {{- end }}
-            - name: WORKER_PORT
-              value: {{ .Values.worker.healthPort | quote }}
-            {{- if .Values.telemetry.enabled }}
-            - name: OTEL_EXPORTER_OTLP_ENDPOINT
-              value: "http://{{ include "sim.fullname" . }}-otel-collector:4318"
-            - name: OTEL_SERVICE_NAME
-              value: sim-worker
-            - name: OTEL_SERVICE_VERSION
-              value: {{ .Chart.AppVersion | quote }}
-            - name: OTEL_RESOURCE_ATTRIBUTES
-              value: "service.name=sim-worker,service.version={{ .Chart.AppVersion }},deployment.environment={{ .Values.worker.env.NODE_ENV }}"
-            {{- end }}
-            {{- range $key, $value := .Values.worker.env }}
-            {{- if ne $key "WORKER_PORT" }}
-            - name: {{ $key }}
-              value: {{ $value | quote }}
-            {{- end }}
-            {{- end }}
-            {{- with .Values.extraEnvVars }}
-            {{- toYaml . | nindent 12 }}
-            {{- end }}
-          envFrom:
-            - secretRef:
-                name: {{ include "sim.appSecretName" . }}
-            {{- if .Values.postgresql.enabled }}
-            - secretRef:
-                name: {{ include "sim.postgresqlSecretName" . }}
-            {{- else if .Values.externalDatabase.enabled }}
-            - secretRef:
-                name: {{ include "sim.externalDbSecretName" . }}
-            {{- end }}
-          livenessProbe:
-            httpGet:
-              path: /health/live
-              port: health
-            initialDelaySeconds: 10
-            periodSeconds: 30
-            timeoutSeconds: 5
-            failureThreshold: 3
-          readinessProbe:
-            httpGet:
-              path: /health
-              port: health
-            initialDelaySeconds: 10
-            periodSeconds: 30
-            timeoutSeconds: 5
-            failureThreshold: 3
-          {{- include "sim.resources" .Values.worker | nindent 10 }}
-          {{- include "sim.securityContext" .Values.worker | nindent 10 }}
-{{- end }}
diff --git a/helm/sim/values.yaml b/helm/sim/values.yaml
index 8d9d6906781..cc345484e98 100644
--- a/helm/sim/values.yaml
+++ b/helm/sim/values.yaml
@@ -96,7 +96,7 @@ app:
     # Optional: API Key Encryption (RECOMMENDED for production)
     # Generate 64-character hex string using: openssl rand -hex 32 (outputs 64 hex chars = 32 bytes)
     API_ENCRYPTION_KEY: ""  # OPTIONAL - encrypts API keys at rest, must be exactly 64 hex characters, if not set keys stored in plain text
-    REDIS_URL: ""           # OPTIONAL - Redis connection string for BullMQ/workers; can also come from app secret or External Secrets
+    REDIS_URL: ""           # OPTIONAL - Redis connection string for caching/sessions; can also come from app secret or External Secrets
     
     # Email & Communication
     EMAIL_VERIFICATION_ENABLED: "false"                   # Enable email verification for user registration and login (defaults to false)
@@ -139,10 +139,8 @@ app:
     OLLAMA_URL: ""                                        # Ollama local LLM server URL
     ELEVENLABS_API_KEY: ""                                # ElevenLabs API key for text-to-speech in deployed chat
     
-    # Admission & Dispatch Queue Configuration
+    # Admission Gate Configuration
     ADMISSION_GATE_MAX_INFLIGHT: "500"                    # Max concurrent in-flight execution requests per pod
-    DISPATCH_MAX_QUEUE_PER_WORKSPACE: "1000"              # Max queued dispatch jobs per workspace
-    DISPATCH_MAX_QUEUE_GLOBAL: "50000"                    # Max queued dispatch jobs globally
 
     # Rate Limiting Configuration (per minute)
     RATE_LIMIT_WINDOW_MS: "60000"                         # Rate limit window duration (1 minute)
@@ -386,58 +384,6 @@ realtime:
   extraVolumes: []
   extraVolumeMounts: []
 
-# BullMQ worker configuration (processes background jobs when Redis is available)
-# Uses the same image as the main app with a different command.
-# Enabled by default so self-hosted deployments get the same topology as compose.
-# Without REDIS_URL the worker starts, logs that it is idle, and does no queue processing.
-worker:
-  # Enable/disable the worker deployment
-  enabled: true
-
-  # Image configuration (defaults to same image as app)
-  image:
-    repository: simstudioai/simstudio
-    tag: latest
-    pullPolicy: Always
-
-  # Number of replicas
-  replicaCount: 1
-
-  # Health check port (worker exposes a lightweight HTTP health server)
-  healthPort: 3001
-
-  # Resource limits and requests
-  resources:
-    limits:
-      memory: "4Gi"
-      cpu: "1000m"
-    requests:
-      memory: "2Gi"
-      cpu: "500m"
-
-  # Node selector for pod scheduling
-  nodeSelector: {}
-
-  # Pod security context
-  podSecurityContext:
-    fsGroup: 1001
-
-  # Container security context
-  securityContext:
-    runAsNonRoot: true
-    runAsUser: 1001
-
-  # Environment variables (worker-specific tuning)
-  env:
-    NODE_ENV: "production"
-    WORKER_CONCURRENCY_WORKFLOW: "50"
-    WORKER_CONCURRENCY_WEBHOOK: "30"
-    WORKER_CONCURRENCY_SCHEDULE: "20"
-    WORKER_CONCURRENCY_MOTHERSHIP_JOB: "10"
-    WORKER_CONCURRENCY_CONNECTOR_SYNC: "5"
-    WORKER_CONCURRENCY_DOCUMENT_PROCESSING: "20"
-    WORKER_CONCURRENCY_NOTIFICATION_DELIVERY: "10"
-
 # Database migrations job configuration
 migrations:
   # Enable/disable migrations job
@@ -1349,7 +1295,7 @@ externalSecrets:
       CRON_SECRET: ""
       # Path to API_ENCRYPTION_KEY in external store (optional)
       API_ENCRYPTION_KEY: ""
-      # Path to REDIS_URL in external store (optional, required for worker when not set in app.env)
+      # Path to REDIS_URL in external store (optional)
       REDIS_URL: ""
 
     # PostgreSQL password (for internal PostgreSQL)
diff --git a/package.json b/package.json
index c7ff404e8c2..1644b48c5fa 100644
--- a/package.json
+++ b/package.json
@@ -21,6 +21,14 @@
     "lint:helm": "helm lint ./helm/sim --strict --values ./helm/sim/test/values-lint.yaml",
     "lint:all": "turbo run lint && bun run lint:helm",
     "check": "turbo run format:check",
+    "mship-contracts:generate": "bun run scripts/sync-mothership-stream-contract.ts",
+    "mship-contracts:check": "bun run scripts/sync-mothership-stream-contract.ts --check",
+    "mship-tools:generate": "bun run scripts/sync-tool-catalog.ts",
+    "mship-tools:check": "bun run scripts/sync-tool-catalog.ts --check",
+    "trace-contracts:generate": "bun run scripts/sync-request-trace-contract.ts",
+    "trace-contracts:check": "bun run scripts/sync-request-trace-contract.ts --check",
+    "mship:generate": "bun run mship-contracts:generate && bun run mship-tools:generate && bun run trace-contracts:generate",
+    "mship:check": "bun run mship-contracts:check && bun run mship-tools:check && bun run trace-contracts:check",
     "prepare": "bun husky",
     "type-check": "turbo run type-check",
     "release": "bun run scripts/create-single-release.ts"
@@ -38,6 +46,7 @@
     "@octokit/rest": "^21.0.0",
     "glob": "13.0.0",
     "husky": "9.1.7",
+    "json-schema-to-typescript": "15.0.4",
     "lint-staged": "16.0.0",
     "turbo": "2.9.3"
   },
diff --git a/packages/testing/src/factories/dag.factory.ts b/packages/testing/src/factories/dag.factory.ts
index 2348a8e0480..2b3bdd74cf9 100644
--- a/packages/testing/src/factories/dag.factory.ts
+++ b/packages/testing/src/factories/dag.factory.ts
@@ -1,6 +1,6 @@
 /**
  * Factory functions for creating DAG (Directed Acyclic Graph) test fixtures.
- * These are used in executor tests for DAG construction and edge management.
+ * These are used in executor tests for DAG construction and edge management
  */
 
 import { createSerializedBlock, type SerializedBlock } from './serialized-block.factory'
diff --git a/scripts/sync-mothership-stream-contract.ts b/scripts/sync-mothership-stream-contract.ts
new file mode 100644
index 00000000000..996e490548e
--- /dev/null
+++ b/scripts/sync-mothership-stream-contract.ts
@@ -0,0 +1,94 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { compile } from 'json-schema-to-typescript'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(SCRIPT_DIR, '..')
+const DEFAULT_CONTRACT_PATH = resolve(
+  ROOT,
+  '../copilot/copilot/contracts/mothership-stream-v1.schema.json'
+)
+const OUTPUT_PATH = resolve(ROOT, 'apps/sim/lib/copilot/generated/mothership-stream-v1.ts')
+const RUNTIME_SCHEMA_OUTPUT_PATH = resolve(
+  ROOT,
+  'apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts'
+)
+
+function generateRuntimeConstants(schema: Record<string, unknown>, existingTypes: string): string {
+  const defs = (schema.$defs ?? schema.definitions ?? {}) as Record<string, unknown>
+  const lines: string[] = []
+
+  for (const [name, def] of Object.entries(defs)) {
+    if (!def || typeof def !== 'object') continue
+    const defObj = def as Record<string, unknown>
+    const enumValues = defObj.enum
+    if (!Array.isArray(enumValues) || enumValues.length === 0) continue
+    if (!enumValues.every((v) => typeof v === 'string')) continue
+
+    const typeAlias = (enumValues as string[]).map((v) => JSON.stringify(v)).join(' | ')
+    const entries = (enumValues as string[])
+      .map((v) => `  ${JSON.stringify(v)}: ${JSON.stringify(v)}`)
+      .join(',\n')
+
+    if (!existingTypes.includes(`export type ${name} =`)) {
+      lines.push(`export type ${name} = ${typeAlias}\n`)
+    }
+
+    lines.push(`export const ${name} = {\n${entries},\n} as const;\n`)
+  }
+
+  return lines.join('\n')
+}
+
+function renderRuntimeSchemaModule(schema: unknown): string {
+  return [
+    '// AUTO-GENERATED FILE. DO NOT EDIT.',
+    '// Generated from copilot/contracts/mothership-stream-v1.schema.json',
+    '//',
+    '',
+    'export type JsonSchema = unknown',
+    '',
+    `export const MOTHERSHIP_STREAM_V1_SCHEMA: JsonSchema = ${JSON.stringify(schema, null, 2)}`,
+    '',
+  ].join('\n')
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check')
+  const inputPathArg = process.argv.find((arg) => arg.startsWith('--input='))
+  const inputPath = inputPathArg
+    ? resolve(ROOT, inputPathArg.slice('--input='.length))
+    : DEFAULT_CONTRACT_PATH
+
+  const raw = await readFile(inputPath, 'utf8')
+  const schema = JSON.parse(raw)
+  const types = await compile(schema, 'MothershipStreamV1EventEnvelope', {
+    bannerComment: '// AUTO-GENERATED FILE. DO NOT EDIT.\n//',
+    unreachableDefinitions: true,
+    additionalProperties: false,
+  })
+
+  const constants = generateRuntimeConstants(schema, types)
+  const rendered = constants ? `${types}\n${constants}\n` : types
+  const renderedSchemaModule = renderRuntimeSchemaModule(schema)
+
+  if (checkOnly) {
+    const existing = await readFile(OUTPUT_PATH, 'utf8').catch(() => null)
+    const existingSchemaModule = await readFile(RUNTIME_SCHEMA_OUTPUT_PATH, 'utf8').catch(
+      () => null
+    )
+    if (existing !== rendered || existingSchemaModule !== renderedSchemaModule) {
+      throw new Error(
+        `Generated mothership stream contract is stale. Run: bun run mship-contracts:generate`
+      )
+    }
+    return
+  }
+
+  await mkdir(dirname(OUTPUT_PATH), { recursive: true })
+  await writeFile(OUTPUT_PATH, rendered, 'utf8')
+  await writeFile(RUNTIME_SCHEMA_OUTPUT_PATH, renderedSchemaModule, 'utf8')
+}
+
+await main()
diff --git a/scripts/sync-request-trace-contract.ts b/scripts/sync-request-trace-contract.ts
new file mode 100644
index 00000000000..2cf7f5c3f05
--- /dev/null
+++ b/scripts/sync-request-trace-contract.ts
@@ -0,0 +1,73 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { compile } from 'json-schema-to-typescript'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(SCRIPT_DIR, '..')
+const DEFAULT_CONTRACT_PATH = resolve(
+  ROOT,
+  '../copilot/copilot/contracts/request-trace-v1.schema.json'
+)
+const OUTPUT_PATH = resolve(ROOT, 'apps/sim/lib/copilot/generated/request-trace-v1.ts')
+
+function generateRuntimeConstants(schema: Record<string, unknown>): string {
+  const defs = (schema.$defs ?? schema.definitions ?? {}) as Record<string, unknown>
+  const lines: string[] = []
+
+  for (const [name, def] of Object.entries(defs)) {
+    if (!def || typeof def !== 'object') continue
+    const defObj = def as Record<string, unknown>
+    const enumValues = defObj.enum
+    if (!Array.isArray(enumValues) || enumValues.length === 0) continue
+    if (!enumValues.every((v) => typeof v === 'string')) continue
+
+    const entries = (enumValues as string[])
+      .map((v) => `  ${JSON.stringify(v)}: ${JSON.stringify(v)}`)
+      .join(',\n')
+
+    lines.push(
+      `export const ${name} = {\n${entries},\n} as const;\n`
+    )
+  }
+
+  return lines.join('\n')
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check')
+  const inputPathArg = process.argv.find((arg) => arg.startsWith('--input='))
+  const inputPath = inputPathArg ? resolve(ROOT, inputPathArg.slice('--input='.length)) : DEFAULT_CONTRACT_PATH
+
+  const raw = await readFile(inputPath, 'utf8')
+  const schema = JSON.parse(raw)
+  const types = await compile(schema, 'RequestTraceV1SimReport', {
+    bannerComment:
+      '// AUTO-GENERATED FILE. DO NOT EDIT.\n//',
+    unreachableDefinitions: true,
+    additionalProperties: false
+  })
+
+  const constants = generateRuntimeConstants(schema)
+  const rendered = constants ? `${types}\n${constants}\n` : types
+
+  if (checkOnly) {
+    const existing = await readFile(OUTPUT_PATH, 'utf8').catch(() => null)
+    if (existing !== rendered) {
+      throw new Error(
+        `Generated request trace contract is stale. Run: bun run trace-contracts:generate`
+      )
+    }
+    console.log('Request trace contract is up to date.')
+    return
+  }
+
+  await mkdir(dirname(OUTPUT_PATH), { recursive: true })
+  await writeFile(OUTPUT_PATH, rendered, 'utf8')
+  console.log(`Generated request trace types -> ${OUTPUT_PATH}`)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})
diff --git a/scripts/sync-tool-catalog.ts b/scripts/sync-tool-catalog.ts
new file mode 100644
index 00000000000..5edf31d7826
--- /dev/null
+++ b/scripts/sync-tool-catalog.ts
@@ -0,0 +1,229 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(SCRIPT_DIR, '..')
+const DEFAULT_CATALOG_PATH = resolve(ROOT, '../copilot/copilot/contracts/tool-catalog-v1.json')
+const OUTPUT_PATH = resolve(ROOT, 'apps/sim/lib/copilot/generated/tool-catalog-v1.ts')
+const RUNTIME_SCHEMA_OUTPUT_PATH = resolve(
+  ROOT,
+  'apps/sim/lib/copilot/generated/tool-schemas-v1.ts'
+)
+
+function snakeToPascal(s: string): string {
+  return s
+    .split('_')
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join('')
+}
+
+function toCamelIdentifier(value: string): string {
+  const parts = value.split(/[^a-zA-Z0-9]+/).filter(Boolean)
+  if (parts.length === 0) return 'value'
+
+  const camel = parts
+    .map((part, index) => {
+      const lower = part.toLowerCase()
+      if (index === 0) return lower
+      return lower.charAt(0).toUpperCase() + lower.slice(1)
+    })
+    .join('')
+
+  return /^[0-9]/.test(camel) ? `v${camel}` : camel
+}
+
+function getTopLevelOperationEnum(tool: Record<string, unknown>): string[] | undefined {
+  const parameters =
+    typeof tool.parameters === 'object' && tool.parameters !== null
+      ? (tool.parameters as Record<string, unknown>)
+      : null
+  const properties =
+    parameters && typeof parameters.properties === 'object' && parameters.properties !== null
+      ? (parameters.properties as Record<string, unknown>)
+      : null
+  const operation =
+    properties && typeof properties.operation === 'object' && properties.operation !== null
+      ? (properties.operation as Record<string, unknown>)
+      : null
+  const values = operation?.enum
+
+  if (!Array.isArray(values) || values.some((value) => typeof value !== 'string')) {
+    return undefined
+  }
+  return values as string[]
+}
+
+function inferTSType(values: unknown[]): string {
+  const unique = [...new Set(values.filter((v) => v !== undefined && v !== null))]
+  if (unique.length === 0) return 'string'
+  if (unique.every((v) => typeof v === 'string')) {
+    return unique
+      .map((v) => JSON.stringify(v))
+      .sort()
+      .join(' | ')
+  }
+  if (unique.every((v) => typeof v === 'boolean')) return 'boolean'
+  if (unique.every((v) => typeof v === 'number')) return 'number'
+  return 'unknown'
+}
+
+function renderRuntimeSchemaModule(catalog: { tools: Record<string, unknown>[] }): string {
+  const lines: string[] = [
+    '// AUTO-GENERATED FILE. DO NOT EDIT.',
+    '// Generated from copilot/contracts/tool-catalog-v1.json',
+    '//',
+    '',
+    'export type JsonSchema = unknown',
+    '',
+    'export interface ToolRuntimeSchemaEntry {',
+    '  parameters?: JsonSchema;',
+    '  resultSchema?: JsonSchema;',
+    '}',
+    '',
+    'export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {',
+  ]
+
+  for (const tool of catalog.tools) {
+    const id = JSON.stringify(tool.id)
+    const parameters =
+      'parameters' in tool ? JSON.stringify(tool.parameters ?? null, null, 2) : 'undefined'
+    const resultSchema =
+      'resultSchema' in tool ? JSON.stringify(tool.resultSchema ?? null, null, 2) : 'undefined'
+    lines.push(`  [${id}]: {`)
+    lines.push(
+      `    parameters: ${parameters === 'null' ? 'undefined' : parameters.replace(/\n/g, '\n    ')},`
+    )
+    lines.push(
+      `    resultSchema: ${resultSchema === 'null' ? 'undefined' : resultSchema.replace(/\n/g, '\n    ')},`
+    )
+    lines.push('  },')
+  }
+
+  lines.push('}')
+  lines.push('')
+  return lines.join('\n')
+}
+
+function generateInterface(tools: Record<string, unknown>[]): string {
+  if (tools.length === 0) return 'export interface ToolCatalogEntry {}\n'
+
+  const allKeys = new Set<string>()
+  for (const tool of tools) {
+    for (const key of Object.keys(tool)) {
+      allKeys.add(key)
+    }
+  }
+
+  const requiredKeys = new Set<string>()
+  for (const key of allKeys) {
+    if (tools.every((t) => key in t)) {
+      requiredKeys.add(key)
+    }
+  }
+
+  const lines: string[] = ['export interface ToolCatalogEntry {']
+  for (const key of [...allKeys].sort()) {
+    const values = tools.map((t) => t[key])
+    const tsType = inferTSType(values)
+    const optional = requiredKeys.has(key) ? '' : '?'
+    lines.push(`  ${key}${optional}: ${tsType};`)
+  }
+  lines.push('}')
+  return lines.join('\n')
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check')
+  const inputPathArg = process.argv.find((arg) => arg.startsWith('--input='))
+  const inputPath = inputPathArg
+    ? resolve(ROOT, inputPathArg.slice('--input='.length))
+    : DEFAULT_CATALOG_PATH
+
+  const raw = await readFile(inputPath, 'utf8')
+  const catalog = JSON.parse(raw) as { version: string; tools: Record<string, unknown>[] }
+
+  const iface = generateInterface(catalog.tools)
+
+  const lines: string[] = [
+    '// AUTO-GENERATED FILE. DO NOT EDIT.',
+    '// Generated from copilot/contracts/tool-catalog-v1.json',
+    '//',
+    '',
+    iface,
+    '',
+  ]
+
+  const constNames: string[] = []
+
+  for (const tool of catalog.tools) {
+    const constName = snakeToPascal(tool.id as string)
+    constNames.push(constName)
+    const fields: string[] = []
+    for (const [key, value] of Object.entries(tool)) {
+      fields.push(`  ${key}: ${JSON.stringify(value)}`)
+    }
+    lines.push(`export const ${constName}: ToolCatalogEntry = {`)
+    lines.push(`${fields.join(',\n')},`)
+    lines.push('};')
+    lines.push('')
+  }
+
+  for (const tool of catalog.tools) {
+    const constName = snakeToPascal(tool.id as string)
+    const operationEnum = getTopLevelOperationEnum(tool)
+    if (!operationEnum || operationEnum.length === 0) continue
+
+    const operationConstName = `${constName}Operation`
+    const seenKeys = new Set<string>()
+    const members = operationEnum.map((value, index) => {
+      let key = toCamelIdentifier(value)
+      if (seenKeys.has(key)) key = `${key}${index + 1}`
+      seenKeys.add(key)
+      return { key, value }
+    })
+
+    lines.push(`export const ${operationConstName} = {`)
+    for (const member of members) {
+      lines.push(`  ${member.key}: ${JSON.stringify(member.value)},`)
+    }
+    lines.push('} as const;')
+    lines.push('')
+    lines.push(
+      `export type ${operationConstName} = (typeof ${operationConstName})[keyof typeof ${operationConstName}];`
+    )
+    lines.push('')
+    lines.push(`export const ${operationConstName}Values = [`)
+    for (const member of members) {
+      lines.push(`  ${operationConstName}.${member.key},`)
+    }
+    lines.push(`] as const;`)
+    lines.push('')
+  }
+
+  lines.push(`export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {`)
+  for (let i = 0; i < catalog.tools.length; i++) {
+    lines.push(`  [${constNames[i]}.id]: ${constNames[i]},`)
+  }
+  lines.push('};')
+  lines.push('')
+
+  const rendered = lines.join('\n')
+  const runtimeSchemaRendered = renderRuntimeSchemaModule(catalog)
+
+  if (checkOnly) {
+    const existing = await readFile(OUTPUT_PATH, 'utf8').catch(() => null)
+    const existingRuntime = await readFile(RUNTIME_SCHEMA_OUTPUT_PATH, 'utf8').catch(() => null)
+    if (existing !== rendered || existingRuntime !== runtimeSchemaRendered) {
+      throw new Error(`Generated tool catalog is stale. Run: bun run mship-tools:generate`)
+    }
+    return
+  }
+
+  await mkdir(dirname(OUTPUT_PATH), { recursive: true })
+  await writeFile(OUTPUT_PATH, rendered, 'utf8')
+  await mkdir(dirname(RUNTIME_SCHEMA_OUTPUT_PATH), { recursive: true })
+  await writeFile(RUNTIME_SCHEMA_OUTPUT_PATH, runtimeSchemaRendered, 'utf8')
+}
+
+await main()