> ## Documentation Index
> Fetch the complete documentation index at: https://docs.forge.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Slack

> Send Registry requests and decisions to Slack and let authorized owners respond in place.

The Slack integration delivers Forge Registry events to a selected channel and
sends requester or owner updates by direct message when Forge can resolve a
Slack identity. Authorized owners can approve or deny supported requests
without leaving Slack.

## Authentication

Forge connects with Slack OAuth. The user connecting Slack must be a Forge
organization owner or administrator and must be allowed to install the Forge
Slack app in the target workspace.

Forge requests these bot scopes:

| Scope               | Use                                                                   |
| ------------------- | --------------------------------------------------------------------- |
| `chat:write`        | Send and update channel and direct messages                           |
| `chat:write.public` | Send to selected public channels without requiring a prior invitation |
| `channels:read`     | List public channels for destination selection                        |
| `groups:read`       | List private channels visible to the app                              |
| `im:write`          | Open direct-message conversations                                     |
| `team:read`         | Record the connected workspace identity                               |
| `users:read`        | Resolve Slack users                                                   |
| `users:read.email`  | Match Slack users to Forge directory identities by email              |

The OAuth bot token is stored as a Forge-managed secret. Forge binds the OAuth
callback to the initiating console user and organization, and the authorization
state expires after ten minutes.

## Events

Slack preferences currently cover Registry activity:

| Event                                       | Notification                                                       |
| ------------------------------------------- | ------------------------------------------------------------------ |
| MCP tool changes                            | A registered MCP server adds tools or changes existing definitions |
| MCP requests                                | A user submits an MCP access request                               |
| Tool requests                               | A user requests access to additional tools                         |
| New submissions                             | A previously unregistered MCP server is submitted                  |
| High risk                                   | An MCP scan produces a high-risk result                            |
| Approved, denied, changes, ready, reconnect | The request reaches the corresponding lifecycle state              |
| Skill submissions, approved, denied         | A skill promotion request is created or decided                    |

Forge sends Registry requests to the configured Registry channel. Requester
updates and owner-specific actions can be delivered by DM when a directory
user is linked to a Slack user in the connected workspace.

See [Notifications](/secure/notifications) to configure governance, Shadow AI,
and Registry event delivery. See [Ownership](/secure/ownership) to route
matching governance requests to specific users and groups.

## Setup

1. In Forge, open **Settings**, then **Slack**.
2. Select **Connect Slack** and authorize the Forge app for the intended
   workspace.
3. Choose the channel used for Registry requests.
4. Enable the Registry event types that should send messages.

Private channels appear only when the installed app can see them. Archived
channels are excluded from the picker. Reconnect Slack if the app was removed,
its token was revoked, or the workspace installation changed.

## Decisions

Supported request messages include **Approve** and **Deny** actions. Forge
verifies the Slack request signature, connected workspace, Slack user, current
request owner, request state, and requested scope before applying a decision.
A denial requires a reason.

Decisions are idempotent. Stale, duplicate, already-resolved, or unauthorized
actions do not change the request. After a successful decision, Forge updates
the original Slack message and records the Slack actor and outcome in the audit
trail.

## Data

Forge reads workspace identity, visible channel metadata, and user identity
fields needed for routing. It does not ingest Slack message history as AI
inventory or session content. The integration sends Forge-generated summaries
and deep links; notification content is bounded to the event and destination.

## Verification

After connecting:

* Confirm the expected Slack workspace is shown as connected.
* Confirm the Registry channel can be selected.
* Submit a test Registry request and verify the channel message.
* Verify that a mapped requester or owner receives the expected DM.
* Complete a supported decision and confirm the Slack message and Forge request
  both show the final state.

If channels cannot be listed, verify `channels:read` and `groups:read` and
confirm the app can see the destination. If DMs do not arrive, verify the
directory email matches the Slack account email and that `users:read.email` and
`im:write` are present.

## Related pages

<CardGroup cols={2}>
  <Card title="Notifications" icon="bell" href="/secure/notifications">
    Configure event delivery and verify recent notification outcomes.
  </Card>

  <Card title="Ownership" icon="users" href="/secure/ownership">
    Assign governance work to the appropriate users and groups.
  </Card>
</CardGroup>