@@ -18,6 +18,9 @@ vi.mock(
 import type { PersistedStreamEventEnvelope } from '@/lib/mothership/request/session/contract'
 import type { FilePreviewSession } from '@/lib/mothership/request/session/file-preview-session-contract'
 import { toStreamBatchEvent } from '@/lib/mothership/request/session/types'
+import { oauthCredentialKeys } from '@/hooks/queries/oauth/oauth-credentials'
+import { workspaceCredentialKeys } from '@/hooks/queries/utils/credential-keys'
+import { selectorQueryRoots } from '@/hooks/queries/utils/selector-keys'
 import { dispatchStreamEvent } from './dispatch-stream-event'
 import { createStreamLoopContext, type StreamLoopContext } from './stream-context'
 import { makeStreamLoopDeps, ref } from './stream-test-helpers'
@@ -84,6 +87,38 @@ function toolNode(ctx: StreamLoopContext, id: string): ToolNode {
 }
 
 describe('tool events (dispatch → model + side effects)', () => {
+  it.each([false, true])(
+    'refreshes credential lists and selectors after Slack connection (replay=%s)',
+    (replay) => {
+      const deps = makeStreamLoopDeps()
+      const ctx = createStreamLoopContext(deps)
+      dispatchStreamEvent(ctx, toolCall('slack', 'connect_slack_bot'))
+      expect(deps.queryClient.invalidateQueries).not.toHaveBeenCalled()
+      const result = toolResult('slack', true, 'connect_slack_bot')
+      dispatchStreamEvent(ctx, replay ? toStreamBatchEvent(result).event : result)
+      expect(deps.queryClient.invalidateQueries).toHaveBeenCalledWith({
+        queryKey: workspaceCredentialKeys.lists(),
+      })
+      expect(deps.queryClient.invalidateQueries).toHaveBeenCalledWith({
+        queryKey: oauthCredentialKeys.lists(),
+      })
+      expect(deps.queryClient.invalidateQueries).toHaveBeenCalledWith({
+        queryKey: selectorQueryRoots.selectors,
+      })
+      expect(deps.queryClient.invalidateQueries).toHaveBeenCalledWith({
+        queryKey: selectorQueryRoots.workflowSearchReplace,
+      })
+    }
+  )
+
+  it('does not refresh credentials after a failed Slack connection', () => {
+    const deps = makeStreamLoopDeps()
+    const ctx = createStreamLoopContext(deps)
+    dispatchStreamEvent(ctx, toolCall('slack', 'connect_slack_bot'))
+    dispatchStreamEvent(ctx, toolResult('slack', false, 'connect_slack_bot'))
+    expect(deps.queryClient.invalidateQueries).not.toHaveBeenCalled()
+  })
+
   it('replays a completed file write without reopening its tab or preview', () => {
     const onResourceEvent = vi.fn()
     const deps = makeStreamLoopDeps({ onResourceEventRef: ref(onResourceEvent) })
 
@@ -4,7 +4,11 @@ import {
   MothershipStreamV1ToolPhase,
   MothershipStreamV1ToolStatus,
 } from '@/lib/mothership/generated/mothership-stream-v1'
-import { ApplyFileEdit, PrepareFileEdit } from '@/lib/mothership/generated/tool-catalog-v1'
+import {
+  ApplyFileEdit,
+  ConnectSlackBot,
+  PrepareFileEdit,
+} from '@/lib/mothership/generated/tool-catalog-v1'
 import type { PersistedStreamEventEnvelope } from '@/lib/mothership/request/session/contract'
 import {
   extractResourcesFromToolResult,
@@ -26,8 +30,11 @@ import {
   type ToolNode,
 } from '@/app/workspace/[workspaceId]/home/hooks/stream/turn-model'
 import { deploymentKeys } from '@/hooks/queries/deployments'
+import { oauthCredentialKeys } from '@/hooks/queries/oauth/oauth-credentials'
+import { workspaceCredentialKeys } from '@/hooks/queries/utils/credential-keys'
 import { folderKeys } from '@/hooks/queries/utils/folder-keys'
 import { invalidateWorkflowLists } from '@/hooks/queries/utils/invalidate-workflow-lists'
+import { invalidateSelectorQueries } from '@/hooks/queries/utils/selector-keys'
 
 type ToolEvent = Extract<PersistedStreamEventEnvelope, { type: 'tool' }>
 
@@ -66,6 +73,11 @@ function runToolResultSideEffects(ctx: StreamLoopContext, node: ToolNode, replay
   if (FOLDER_TOOL_NAMES.has(name) && isSuccess) {
     deps.queryClient.invalidateQueries({ queryKey: folderKeys.list(deps.workspaceId) })
   }
+  if (name === ConnectSlackBot.id && isSuccess) {
+    void deps.queryClient.invalidateQueries({ queryKey: workspaceCredentialKeys.lists() })
+    void deps.queryClient.invalidateQueries({ queryKey: oauthCredentialKeys.lists() })
+    void invalidateSelectorQueries(deps.queryClient)
+  }
   if (WORKFLOW_MUTATION_TOOL_NAMES.has(name) && isSuccess) {
     // `rm` archives, so the archived list moves too — and the shared helper also
     // refreshes the workflow selector lists that `@`-mentions and pickers read.
 
@@ -127,7 +127,7 @@ export const credentialOperations = {
     minimumRole: 'write',
     workspaceApiKey: 'deny',
     capability: 'integrations.manage',
-    principalKinds: ['session', 'personal_api_key', 'oauth_access_token'],
+    ...HUMAN_AND_COPILOT_PRINCIPALS,
   }),
   read: defineCredentialOperation(
     defineWorkspaceOperation({
 
@@ -15,6 +15,7 @@ const mocks = vi.hoisted(() => ({
   getActor: vi.fn(),
   deleteRecord: vi.fn(),
   capture: vi.fn(),
+  environment: vi.fn(),
 }))
 
 vi.mock('@sim/audit', () => auditMock)
@@ -47,11 +48,13 @@ vi.mock('@/lib/credentials/access', () => ({
   },
 }))
 vi.mock('@/lib/posthog/server', () => ({ captureServerEvent: mocks.capture }))
+vi.mock('@/lib/environment/utils', () => ({ getEffectiveDecryptedEnv: mocks.environment }))
 
 import {
   createServiceAccountCredentialUseCase,
   deleteCredentialUseCase,
 } from '@/lib/credentials/application/service-account'
+import { executeCopilotCredentialUseCase } from '@/lib/mothership/application/execute-credential-use-case'
 
 const WORKSPACE_ID = 'workspace-1'
 const workspace = {
@@ -106,6 +109,7 @@ describe('credential service-account application operations', () => {
       providerId: 'zoom-service-account',
       available: true,
     })
+    mocks.environment.mockResolvedValue({ SIGNING: 'secret-signing', BOT: 'secret-bot' })
   })
 
   it('rejects workspace keys before canonical loading on create', async () => {
@@ -158,6 +162,111 @@ describe('credential service-account application operations', () => {
     )
   })
 
+  const storedInput = {
+    workspaceId: WORKSPACE_ID,
+    displayName: 'Support bot',
+    storedSlackSecrets: { signingSecretEnvVar: 'SIGNING', botTokenEnvVar: 'BOT' },
+  }
+  const copilotContext = {
+    userId: 'user-1',
+    workspaceId: WORKSPACE_ID,
+    toolCallId: 'tool-1',
+    copilotToolExecution: true,
+  }
+  const connectStored = (context = copilotContext, input = storedInput) =>
+    executeCopilotCredentialUseCase(context, createServiceAccountCredentialUseCase, input)
+
+  it('resolves stored Slack secrets as the delegated user and audits only credential metadata', async () => {
+    await connectStored()
+    expect(mocks.environment).toHaveBeenCalledWith('user-1', WORKSPACE_ID)
+    expect(mocks.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceId: WORKSPACE_ID,
+        userId: 'user-1',
+        providerId: 'slack-custom-bot',
+        signingSecret: 'secret-signing',
+        botToken: 'secret-bot',
+        displayName: 'Support bot',
+      })
+    )
+    expect(mocks.create.mock.calls[0][0]).not.toHaveProperty('storedSlackSecrets')
+    expect(auditMockFns.mockRecordAudit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        actorId: 'user-1',
+        metadata: expect.objectContaining({
+          operation: 'credentials.service_accounts.create',
+          actor: expect.objectContaining({
+            kind: 'delegated',
+            serviceId: 'copilot',
+            subjectUserId: 'user-1',
+          }),
+        }),
+      })
+    )
+    expect(JSON.stringify(auditMockFns.mockRecordAudit.mock.calls)).not.toContain('secret-signing')
+    expect(JSON.stringify(mocks.capture.mock.calls)).not.toContain('secret-bot')
+  })
+
+  it('rejects forged execution context before canonical loading', async () => {
+    await expect(async () =>
+      connectStored({ ...copilotContext, copilotToolExecution: false })
+    ).rejects.toThrow('trusted')
+    expect(mocks.loadWorkspace).not.toHaveBeenCalled()
+    expect(mocks.environment).not.toHaveBeenCalled()
+  })
+
+  it('rejects cross-workspace delegation before resolving stored secrets', async () => {
+    mocks.loadWorkspace.mockResolvedValueOnce({ ...workspace, workspaceId: 'other' })
+    await expect(
+      connectStored(copilotContext, { ...storedInput, workspaceId: 'other' })
+    ).rejects.toMatchObject({ code: 'forbidden' })
+    expect(mocks.environment).not.toHaveBeenCalled()
+    expect(mocks.create).not.toHaveBeenCalled()
+  })
+
+  it('checks current write permission before resolving stored secrets', async () => {
+    mocks.resolvePermission.mockResolvedValue('read')
+    await expect(connectStored()).rejects.toMatchObject({ code: 'forbidden' })
+    expect(mocks.environment).not.toHaveBeenCalled()
+    expect(mocks.create).not.toHaveBeenCalled()
+  })
+
+  it('checks provider visibility before resolving stored secrets', async () => {
+    mocks.requireProvider.mockImplementationOnce(() => {
+      throw new OrchestrationError('conflict', 'Provider hidden')
+    })
+    await expect(connectStored()).rejects.toMatchObject({ code: 'conflict' })
+    expect(mocks.environment).not.toHaveBeenCalled()
+    expect(mocks.create).not.toHaveBeenCalled()
+  })
+
+  it('reports missing names without sending any partial credential to the provider', async () => {
+    mocks.environment.mockResolvedValue({ SIGNING: 'secret-signing' })
+    await expect(connectStored()).rejects.toThrow('Stored secrets unavailable: BOT')
+    expect(mocks.create).not.toHaveBeenCalled()
+    expect(auditMockFns.mockRecordAudit).not.toHaveBeenCalled()
+  })
+
+  it('does not let delegated callers supply inline credential values', async () => {
+    await expect(
+      executeCopilotCredentialUseCase(copilotContext, createServiceAccountCredentialUseCase, {
+        workspaceId: WORKSPACE_ID,
+        providerId: 'slack-custom-bot',
+        signingSecret: 'raw-signing',
+        botToken: 'raw-token',
+      })
+    ).rejects.toThrow('must reference existing Sim secrets')
+    expect(mocks.environment).not.toHaveBeenCalled()
+    expect(mocks.create).not.toHaveBeenCalled()
+  })
+
+  it('does not duplicate creation audit or analytics when the primitive reuses a credential', async () => {
+    mocks.create.mockResolvedValue({ success: true, credential, created: false })
+    expect((await connectStored()).created).toBe(false)
+    expect(auditMockFns.mockRecordAudit).not.toHaveBeenCalled()
+    expect(mocks.capture).not.toHaveBeenCalled()
+  })
+
   it('rejects service-account providers hidden by workspace policy', async () => {
     mocks.requireProvider.mockImplementation(() => {
       throw new OrchestrationError(
 
@@ -5,6 +5,7 @@ import { ForbiddenOperationError } from '@/lib/core/application/forbidden'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { HttpError } from '@/lib/core/utils/http-error'
 import { getCredentialActorContext, requireOrdinaryCredentialType } from '@/lib/credentials/access'
+import { credentialDelegationPolicy } from '@/lib/credentials/application/authorization'
 import {
   defineAuthorizedCredentialUseCase,
   requireManageableCredentialType,
@@ -21,13 +22,24 @@ import {
   deleteCredentialRecord,
 } from '@/lib/credentials/orchestration'
 import type { CredentialRow } from '@/lib/credentials/queries'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+import { SLACK_CUSTOM_BOT_PROVIDER_ID } from '@/lib/oauth/types'
 import { captureServerEvent } from '@/lib/posthog/server'
 import { loadActiveWorkspaceApplicationContext } from '@/lib/workspaces/application/workspace-context'
 
-export type CreateServiceAccountInput = Omit<
-  CreateServiceAccountCredentialParams,
-  'userId' | 'request'
->
+type InlineServiceAccountInput = Omit<CreateServiceAccountCredentialParams, 'userId' | 'request'>
+
+export interface StoredSlackBotCredentialInput {
+  workspaceId: string
+  displayName: string
+  description?: string
+  storedSlackSecrets: {
+    signingSecretEnvVar: string
+    botTokenEnvVar: string
+  }
+}
+
+export type CreateServiceAccountInput = InlineServiceAccountInput | StoredSlackBotCredentialInput
 
 export interface CreateServiceAccountResult {
   credential: CredentialRow
@@ -53,14 +65,44 @@ export const createServiceAccountCredentialUseCase = defineAuthorizedWorkspaceUs
     if (!context) throw new OrchestrationError('not_found', 'Workspace not found')
     return context
   },
-  authorizationOptions: {},
+  authorizationOptions: { delegation: credentialDelegationPolicy },
   async execute({ principal, input, context, request }): Promise<CreateServiceAccountResult> {
+    const stored = 'storedSlackSecrets' in input
+    if (principal.kind === 'delegated' && !stored) {
+      throw new OrchestrationError('validation', 'Copilot must reference existing Sim secrets')
+    }
     const catalog = await listCredentialProviderCatalog(principal, context)
-    requireAvailableServiceAccountCredentialProvider(catalog, input.providerId)
+    const providerId = stored ? SLACK_CUSTOM_BOT_PROVIDER_ID : input.providerId
+    requireAvailableServiceAccountCredentialProvider(catalog, providerId)
+    const userId = requirePrincipalSubjectUserId(principal)
+    let credentialInput: InlineServiceAccountInput
+    if (stored) {
+      const { signingSecretEnvVar, botTokenEnvVar } = input.storedSlackSecrets
+      const environment = await getEffectiveDecryptedEnv(userId, context.workspaceId)
+      const missing = [signingSecretEnvVar, botTokenEnvVar].filter(
+        (name) => !Object.hasOwn(environment, name) || !environment[name]
+      )
+      if (missing.length) {
+        throw new OrchestrationError(
+          'validation',
+          `Stored secrets unavailable: ${missing.join(', ')}`
+        )
+      }
+      credentialInput = {
+        workspaceId: context.workspaceId,
+        providerId,
+        displayName: input.displayName,
+        description: input.description,
+        signingSecret: environment[signingSecretEnvVar],
+        botToken: environment[botTokenEnvVar],
+      }
+    } else {
+      credentialInput = input
+    }
     const result = await createServiceAccountCredential({
-      ...input,
+      ...credentialInput,
       workspaceId: context.workspaceId,
-      userId: requirePrincipalSubjectUserId(principal),
+      userId,
       request,
     })
     if (!result.success) {
 
@@ -0,0 +1,14 @@
+import { CREDENTIAL_DELEGATION_AUDIENCE } from '@/lib/credentials/application/authorization'
+import { credentialOperations } from '@/lib/credentials/application/operations'
+import { createCopilotApplicationAdapter } from '@/lib/mothership/application/application-adapter'
+import { COPILOT_APPLICATION_DELEGATION_TTL_MS } from '@/lib/mothership/auth/application-delegation'
+
+export const executeCopilotCredentialUseCase = createCopilotApplicationAdapter({
+  domain: 'credential',
+  delegation: {
+    audience: CREDENTIAL_DELEGATION_AUDIENCE,
+    ttlMs: COPILOT_APPLICATION_DELEGATION_TTL_MS,
+    createDelegationId: (context) => `copilot-tool:${context.toolCallId}`,
+  },
+  operations: credentialOperations,
+})
@@ -32,6 +32,14 @@ export const ToolActivity = z
   });
 export type ToolActivity = z.infer<typeof ToolActivity>;
 
+/** Existing Sim secret names; plaintext credentials never enter this tool's arguments. */
+export const ConnectSlackBotInputSchema = z.strictObject({
+  displayName: z.string().trim().min(1).max(255),
+  description: z.string().max(1_000).optional(),
+  signingSecretEnvVar: z.string().trim().min(1).max(1_024),
+  botTokenEnvVar: z.string().trim().min(1).max(1_024),
+});
+
 /** Activity acknowledged through a completed leg, scoped to one emitter's lifetime. */
 export interface StreamActivityReceipt {
   emitterId: string;
 
@@ -1,12 +1,14 @@
 import { createLogger } from '@sim/logger'
 import {
   CancelWorkflowRun,
+  ConnectSlackBot,
   GenerateApiKey,
   RunBlock,
   RunFromBlock,
   RunWorkflow,
   RunWorkflowUntilBlock,
 } from '@/lib/mothership/generated/tool-catalog-v1'
+import { executeConnectSlackBot } from '@/lib/mothership/tools/handlers/connect-slack-bot'
 import { createServerToolHandler } from '@/lib/mothership/tools/registry/server-tool-adapter'
 import { getRegisteredServerToolNames } from '@/lib/mothership/tools/server/router'
 import { executeFunctionExecute } from '../tools/handlers/function-execute'
@@ -53,6 +55,7 @@ function buildHandlerMap(): Record<string, ToolHandler> {
   return {
     [CancelWorkflowRun.id]: h(executeCancelWorkflowRun),
     [GenerateApiKey.id]: h(executeGenerateApiKey),
+    [ConnectSlackBot.id]: executeConnectSlackBot,
     [RunWorkflow.id]: h(executeRunWorkflow),
     [RunWorkflowUntilBlock.id]: h(executeRunWorkflowUntilBlock),
     [RunFromBlock.id]: h(executeRunFromBlock),