@windyroad/connect 0.2.1-preview.38 → 0.3.0-preview.41

package/hooks/session-start.sh

@@ -1,18 +1,28 @@
 #!/bin/bash
 # wr-connect - SessionStart hook
-# Warns if env vars are configured but --channels is not active.
+# Outputs collaboration primer when Discord channel is active.
 # Always exits 0 (warns, never blocks).
 
-# If bot token is not set, plugin is inactive — exit silently
-if [ -z "${WR_CONNECT_BOT_TOKEN:-}" ]; then
+# Check if the Discord plugin is configured (token saved)
+DISCORD_ENV="$HOME/.claude/channels/discord/.env"
+if [ ! -f "$DISCORD_ENV" ]; then
+  # Discord plugin not configured — plugin is inactive, exit silently
   exit 0
 fi
 
-# If --channels is active, output collaboration primer
+# Check if --channels is active
 # NOTE: CLAUDE_CHANNELS is the expected env var when --channels is active.
 # This may change in future Claude Code versions; update if needed.
 if [ -n "${CLAUDE_CHANNELS:-}" ]; then
-  SESSION_NAME="${WR_CONNECT_SESSION_NAME:-unnamed}"
+  # Detect session name from env var or git remote
+  SESSION_NAME="${WR_CONNECT_SESSION_NAME:-}"
+  if [ -z "$SESSION_NAME" ]; then
+    SESSION_NAME=$(git remote get-url origin 2>/dev/null | sed 's|.*github.com[:/]||;s|\.git$||' || echo "")
+  fi
+  if [ -z "$SESSION_NAME" ]; then
+    SESSION_NAME=$(basename "$PWD")
+  fi
+
   cat <<PRIMER
 wr-connect: Collaboration channel active. Your session name is "${SESSION_NAME}".
 
@@ -30,13 +40,14 @@ SENDING:
 - Use /wr-connect:send to message the channel.
 - Use @<session-name> to direct a message to a specific session.
 - Be concise — other sessions will read your messages too.
+- Always prefix your replies with **${SESSION_NAME}:** so others know who sent it.
 PRIMER
   exit 0
 fi
 
-# Env vars set but --channels not active — warn
+# Discord configured but --channels not active — warn
 cat <<'EOF'
-wr-connect: Environment configured but --channels is not active.
+wr-connect: Discord is configured but --channels is not active.
 To enable cross-repo collaboration, restart with:
   claude --channels plugin:discord@claude-plugins-official
 EOF

package/hooks/test/session-start.bats

@@ -1,48 +1,66 @@
 #!/usr/bin/env bats
 
 # Tests for session-start.sh (SessionStart hook)
-# Verifies three states: no config, config without channels, config with channels.
+# Verifies: no config, config without channels, config with channels.
 
 setup() {
   SCRIPT_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
   HOOK="$SCRIPT_DIR/session-start.sh"
-  # Clear env vars for each test
-  unset WR_CONNECT_BOT_TOKEN
-  unset WR_CONNECT_CHANNEL_ID
-  unset WR_CONNECT_SESSION_NAME
+  # Set up a fake Discord config
+  TEST_DIR=$(mktemp -d)
+  export HOME="$TEST_DIR"
   unset CLAUDE_CHANNELS
+  unset WR_CONNECT_SESSION_NAME
+}
+
+teardown() {
+  rm -rf "$TEST_DIR"
 }
 
-@test "no env vars: exits 0, no output" {
+@test "no discord config: exits 0, no output" {
   run "$HOOK"
   [ "$status" -eq 0 ]
   [ -z "$output" ]
 }
 
-@test "env vars set, no CLAUDE_CHANNELS: exits 0, warns about --channels" {
-  export WR_CONNECT_BOT_TOKEN="test-token"
+@test "discord configured, no CLAUDE_CHANNELS: exits 0, warns about --channels" {
+  mkdir -p "$HOME/.claude/channels/discord"
+  echo "DISCORD_BOT_TOKEN=test" > "$HOME/.claude/channels/discord/.env"
   run "$HOOK"
   [ "$status" -eq 0 ]
   [[ "$output" == *"--channels"* ]]
   [[ "$output" == *"plugin:discord@claude-plugins-official"* ]]
 }
 
-@test "env vars set, CLAUDE_CHANNELS active: exits 0, outputs primer with session name" {
-  export WR_CONNECT_BOT_TOKEN="test-token"
-  export WR_CONNECT_SESSION_NAME="repo-b"
+@test "discord configured, CLAUDE_CHANNELS active: exits 0, outputs primer" {
+  mkdir -p "$HOME/.claude/channels/discord"
+  echo "DISCORD_BOT_TOKEN=test" > "$HOME/.claude/channels/discord/.env"
   export CLAUDE_CHANNELS=1
+  export WR_CONNECT_SESSION_NAME="test-repo"
   run "$HOOK"
   [ "$status" -eq 0 ]
-  [[ "$output" == *"repo-b"* ]]
-  [[ "$output" == *"@repo-b"* ]]
+  [[ "$output" == *"test-repo"* ]]
+  [[ "$output" == *"@test-repo"* ]]
 }
 
 @test "primer tells agent to prioritise @mentions" {
-  export WR_CONNECT_BOT_TOKEN="test-token"
-  export WR_CONNECT_SESSION_NAME="my-repo"
+  mkdir -p "$HOME/.claude/channels/discord"
+  echo "DISCORD_BOT_TOKEN=test" > "$HOME/.claude/channels/discord/.env"
   export CLAUDE_CHANNELS=1
+  export WR_CONNECT_SESSION_NAME="my-repo"
   run "$HOOK"
   [ "$status" -eq 0 ]
   [[ "$output" == *"@my-repo"* ]]
   [[ "$output" == *"relevant"* ]]
 }
+
+@test "primer includes prefix instruction" {
+  mkdir -p "$HOME/.claude/channels/discord"
+  echo "DISCORD_BOT_TOKEN=test" > "$HOME/.claude/channels/discord/.env"
+  export CLAUDE_CHANNELS=1
+  export WR_CONNECT_SESSION_NAME="my-repo"
+  run "$HOOK"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"prefix"* ]]
+  [[ "$output" == *"my-repo"* ]]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/connect",
-  "version": "0.2.1-preview.38",
+  "version": "0.3.0-preview.41",
   "description": "Connect Claude Code sessions across repos via Discord (experimental)",
   "bin": {
     "windyroad-connect": "./bin/install.mjs"

package/skills/send/SKILL.md

@@ -1,34 +1,49 @@
 ---
 name: wr-connect:send
-description: Send a message to other Claude Code sessions via Discord.
-allowed-tools: Bash, AskUserQuestion
+description: Send a message to other Claude Code sessions via the Discord channel.
+allowed-tools: Bash, AskUserQuestion, mcp__plugin_discord_discord__reply, mcp__plugin_discord_discord__react, mcp__plugin_discord_discord__fetch_messages
 ---
 
 # Send Message
 
-Send a message from this session to other Claude Code sessions listening on the
-configured Discord channel.
+Send a message from this session to other Claude Code sessions on the shared
+Discord channel. Uses the Discord plugin's reply tool directly.
+
+## Prerequisites
+
+The Discord channel plugin must be active (`--channels plugin:discord@claude-plugins-official`).
+If not set up, run `/wr-connect:setup` first.
 
 ## Instructions
 
-### 1. Check environment variables
+### 1. Determine the channel
 
-Verify these environment variables are set:
-- `WR_CONNECT_BOT_TOKEN`
-- `WR_CONNECT_CHANNEL_ID`
-- `WR_CONNECT_SESSION_NAME`
+Check if `WR_CONNECT_CHANNEL_ID` is set:
 
 ```bash
-[ -n "$WR_CONNECT_BOT_TOKEN" ] && [ -n "$WR_CONNECT_CHANNEL_ID" ] && [ -n "$WR_CONNECT_SESSION_NAME" ] && echo "OK" || echo "MISSING"
+echo "${WR_CONNECT_CHANNEL_ID:-NOT SET}"
 ```
 
-If any are missing, tell the user:
+If not set, use `fetch_messages` to find the active guild channel, or ask the user
+which channel to send to via AskUserQuestion.
 
-> wr-connect is not configured. Run `/wr-connect:setup` first.
+### 2. Determine session name
 
-Then stop.
+Check if `WR_CONNECT_SESSION_NAME` is set:
 
-### 2. Get the message
+```bash
+echo "${WR_CONNECT_SESSION_NAME:-}"
+```
+
+If not set, detect from git remote:
+
+```bash
+git remote get-url origin 2>/dev/null | sed 's|.*github.com[:/]||;s|\.git$||'
+```
+
+If neither works, use the current directory name.
+
+### 3. Get the message
 
 The message to send is provided via `$ARGUMENTS`.
 
@@ -37,34 +52,22 @@ If `$ARGUMENTS` is empty, use AskUserQuestion to ask:
 > What message would you like to send to the other session(s)?
 > To direct your message to a specific session, start with @session-name.
 
-### 3. Send the message
+### 4. Send the message
 
-Format the message as: `[wr-connect] from: <SESSION_NAME> | <message>`
+Format the message as: `**<session-name>:** <message>`
 
-**@mentions:** If the user's message starts with `@<name>`, preserve it as-is in the
-message body. This tells the target session to prioritise the message. Messages
-without an `@` are treated as broadcast to all listening sessions.
+Use the Discord plugin's `reply` tool to send it to the channel:
 
-Send via the Discord API:
-
-```bash
-curl -s -o /tmp/wr-connect-response.json -w "%{http_code}" \
-  -X POST "https://discord.com/api/v10/channels/${WR_CONNECT_CHANNEL_ID}/messages" \
-  -H "Authorization: Bot ${WR_CONNECT_BOT_TOKEN}" \
-  -H "Content-Type: application/json" \
-  -d "{\"content\": \"[wr-connect] from: ${WR_CONNECT_SESSION_NAME} | <MESSAGE>\"}"
+```
+reply(chat_id: "<channel-id>", text: "**<session-name>:** <message>")
 ```
 
-Replace `<MESSAGE>` with the actual message content. Escape any double quotes in the
-message before inserting into the JSON payload.
+**@mentions:** If the user's message starts with `@<name>`, preserve it in the
+message body. This tells the target session to prioritise the message.
 
-### 4. Report result
+### 5. Report result
 
-Check the HTTP status code returned by curl:
-- **200** or **201**: Message sent successfully. Report the formatted message to the user.
-- **429**: Rate limited. Tell the user to wait a moment and try again.
-- **401** or **403**: Authentication failed. Tell the user to check their bot token.
-- **Other**: Report the status code and response body for debugging.
+Confirm the message was sent and show the formatted text.
 
 ## Examples
 
@@ -74,16 +77,16 @@ Check the HTTP status code returned by curl:
 ```
 Sends:
 ```
-[wr-connect] from: repo-a | BUG: Widget.parse() throws on null input at line 47
+**windyroad/agent-plugins:** BUG: Widget.parse() throws on null input at line 47
 ```
 
 **Directed (specific session):**
 ```
-/wr-connect:send @repo-b BUG: Widget.parse() throws on null input at line 47
+/wr-connect:send @bbstats please fix Widget.parse()
 ```
 Sends:
 ```
-[wr-connect] from: repo-a | @repo-b BUG: Widget.parse() throws on null input at line 47
+**windyroad/agent-plugins:** @bbstats please fix Widget.parse()
 ```
 
 $ARGUMENTS

package/skills/setup/SKILL.md

@@ -15,6 +15,9 @@ across different repos can communicate with zero idle token cost.
 **This is an interactive walkthrough.** Use AskUserQuestion at each step to confirm
 progress and gather details. Do NOT skip ahead — wait for the user at each checkpoint.
 
+**Important:** Each repo should have its own Discord bot so sessions are
+distinguishable in Discord. The bot name defaults to the org/repo from git remote.
+
 ## Steps
 
 ### 1. Explain and opt-in
@@ -27,10 +30,11 @@ Tell the user:
 > wasting tokens. Sessions can hand off findings, ask questions, share context, or
 > coordinate work.
 >
-> It works by using Discord as a message channel. You will need:
+> Each repo gets its own Discord bot (so you can tell sessions apart in Discord).
+> You will need:
 > - A Discord account
-> - A Discord bot (created in the next step)
-> - A private Discord server or channel
+> - A Discord server with a channel for agent collaboration
+> - A few minutes to create a bot in the Discord Developer Portal
 
 Use AskUserQuestion:
 - "Would you like to proceed with setting up cross-repo collaboration via Discord?"
@@ -42,201 +46,191 @@ If no:
 
 Stop — do not proceed.
 
-### 2. Check for existing Discord server
+### 2. Detect bot name
+
+Detect the org/repo from git remote to suggest a bot name:
+
+```bash
+git remote get-url origin 2>/dev/null | sed 's|.*github.com[:/]||;s|\.git$||' | tr '/' '-'
+```
+
+If no remote is found, use the directory name as a fallback.
+
+Use AskUserQuestion:
+- "What should the Discord bot be called? This name will appear in Discord when this session sends messages."
+- Options: "<detected-name>" (e.g., "windyroad-agent-plugins") / "I want a different name"
+
+### 3. Check for existing Discord server
 
 Use AskUserQuestion:
-- "Do you already have a Discord server you'd like to use, or do you need to create one?"
+- "Do you already have a Discord server for agent collaboration, or do you need to create one?"
 - Options: "I have a server" / "I need to create one"
 
 If they need to create one, guide them:
 1. Open Discord and click the **+** button in the server list
 2. Choose **Create My Own** > **For me and my friends**
-3. Name it something like `dev-agents` or `wr-connect`
+3. Name it something like `dev-agents`
+4. Create a private channel (e.g., `#agent-collab`)
 
-### 3. Create a Discord bot
+### 4. Create a Discord bot
 
-Tell the user to go to https://discord.com/developers/applications, then guide
-them step by step. Use AskUserQuestion after giving the instructions:
+Tell the user to go to https://discord.com/developers/applications:
 
 **Instructions:**
-1. Click **New Application** — name it `wr-connect`
-2. Go to **Bot** > click **Add Bot** > confirm
-3. Under **Token**, click **Reset Token** and copy the token
+1. Click **New Application** — name it `<detected-bot-name>` from step 2
+2. Go to **Bot** in the sidebar. Give the bot the same username.
+3. Under **Token**, click **Reset Token** and copy the token (shown once).
 4. Under **Privileged Gateway Intents**, enable:
    - **Message Content Intent** (to read message text)
-   - **Server Members Intent** (optional — for member awareness)
 5. Go to **OAuth2 > URL Generator**:
    - Scopes: `bot`
-   - Bot permissions: `Send Messages`, `Read Messages/View Channels`, `Add Reactions`, `Read Message History`
+   - Bot permissions: `View Channels`, `Send Messages`, `Send Messages in Threads`,
+     `Read Message History`, `Attach Files`, `Add Reactions`
+   - Integration type: **Guild Install**
 6. Copy the generated URL, open it in a browser, and add the bot to your server
 
 Use AskUserQuestion:
 - "Have you created the bot and copied the token?"
 - Options: "Yes, I have the token" / "I need help with a step"
 
-If they need help, ask which step is unclear and provide more detail.
+If they need help, ask which step is unclear.
 
-### 4. Get the channel ID
+### 5. Configure the Discord plugin with the token
 
-Tell the user:
-1. In Discord, go to **User Settings > Advanced** and enable **Developer Mode**
-2. Create a channel (e.g., `#agent-collab`) or pick an existing one
-3. Right-click the channel and click **Copy Channel ID**
-
-Use AskUserQuestion:
-- "Have you copied the channel ID?"
-- Options: "Yes, I have the channel ID" / "I need help"
+Tell the user to run the following command. **Do NOT paste the token yourself** —
+the user should type it directly to avoid the token appearing in conversation history:
 
-### 5. Store credentials
+> Run this command, replacing `<token>` with the bot token you copied:
+> ```
+> /discord:configure <token>
+> ```
+> This saves the token securely at `~/.claude/channels/discord/.env`.
 
 Use AskUserQuestion:
-- "Where would you like to store the bot token and channel ID?"
-- Options:
-  - ".env file (recommended)" — "Store in a .env file in the project root. The file must be in .gitignore."
-  - "1Password CLI" — "Use `op` CLI to store secrets in 1Password and reference them via `op://`"
-  - "Shell profile" — "Add exports to ~/.zshrc or ~/.bashrc"
-
-**If .env file:**
+- "Have you run `/discord:configure` with your token?"
+- Options: "Yes, token is configured" / "I need help"
 
-Check that `.env` is in `.gitignore`:
-```bash
-grep -q '\.env' .gitignore 2>/dev/null && echo ".env is in .gitignore" || echo "WARNING: .env is NOT in .gitignore"
-```
+### 6. Restart with channels active
 
-If not in `.gitignore`, warn the user and offer to add it.
-
-Use AskUserQuestion to get the values:
-- "Paste your bot token (from step 3):"
-- "Paste your channel ID (from step 4):"
-- "What should this session be called? (e.g., `windyroad-plugins`, `repo-a`)"
-
-Write the `.env` file (or append to it if it exists):
-```
-WR_CONNECT_BOT_TOKEN=<token>
-WR_CONNECT_CHANNEL_ID=<channel-id>
-WR_CONNECT_SESSION_NAME=<session-name>
-```
+Tell the user:
 
-**If 1Password CLI:**
+> You need to restart Claude Code with the channels flag to connect to Discord:
+> ```
+> claude --channels plugin:discord@claude-plugins-official
+> ```
+> The Discord plugin won't connect without this flag.
 
-Check if `op` is available:
-```bash
-command -v op && echo "1Password CLI available" || echo "1Password CLI not found"
-```
+Use AskUserQuestion:
+- "Have you restarted with `--channels`? (If we're in a new session, just confirm)"
+- Options: "Yes, restarted" / "Not yet — I'll do it after setup"
 
-Guide the user to create a vault item and reference it:
-```bash
-op item create --category=API\ Credential --title="wr-connect" \
-  'bot_token=<token>' \
-  'channel_id=<channel-id>' \
-  'session_name=<session-name>'
-```
+If not yet, note that steps 7-9 must be done in the restarted session.
 
-Then add to shell profile:
-```bash
-export WR_CONNECT_BOT_TOKEN="$(op read 'op://Private/wr-connect/bot_token')"
-export WR_CONNECT_CHANNEL_ID="$(op read 'op://Private/wr-connect/channel_id')"
-export WR_CONNECT_SESSION_NAME="$(op read 'op://Private/wr-connect/session_name')"
-```
+### 7. Pair via DM
 
-**If shell profile:**
+Tell the user:
 
-Use AskUserQuestion to get the values (same as .env), then tell the user to add
-the exports to their `~/.zshrc` or `~/.bashrc` and run `source ~/.zshrc`.
+> Open Discord and send a DM to your bot. The bot will reply with a 6-character
+> pairing code. Then run:
+> ```
+> /discord:access pair <code>
+> ```
+> This adds your Discord user ID to the allowlist.
 
-**Security warning:** The bot token gives anyone who has it the ability to send
-messages to your Claude Code session. Never commit it to source control.
+Use AskUserQuestion:
+- "Have you paired successfully?"
+- Options: "Yes, I'm paired" / "The bot didn't respond" / "I need help"
 
-### 6. Verify environment variables
+If the bot didn't respond:
+- Check that the session is running with `--channels`
+- Check that the token was saved correctly (`/discord:configure` with no args shows status)
 
-Check the env vars are set in the current shell:
+### 8. Lock down access
 
-```bash
-[ -n "$WR_CONNECT_BOT_TOKEN" ] && echo "BOT_TOKEN: set" || echo "BOT_TOKEN: NOT SET"
-[ -n "$WR_CONNECT_CHANNEL_ID" ] && echo "CHANNEL_ID: set" || echo "CHANNEL_ID: NOT SET"
-[ -n "$WR_CONNECT_SESSION_NAME" ] && echo "SESSION_NAME: set" || echo "SESSION_NAME: NOT SET"
-```
+Tell the user:
 
-If any are not set:
-- For .env: remind the user to run `source .env` or check the file
-- For 1Password: remind the user to run `eval $(op signin)` first
-- For shell profile: remind the user to `source ~/.zshrc`
+> Now let's lock down access so only you can reach this session via Discord.
+> Switch from `pairing` mode (which lets anyone trigger pairing codes) to
+> `allowlist` mode:
+> ```
+> /discord:access policy allowlist
+> ```
 
 Use AskUserQuestion:
-- "Are all three variables showing as set?"
-- Options: "Yes, all set" / "No, some are missing"
+- "Have you locked down to allowlist policy?"
+- Options: "Yes, locked down" / "I want to add more people first"
 
-If missing, help troubleshoot.
+If they want to add more people, guide them:
+> Have them DM the bot to get a pairing code, then approve with
+> `/discord:access pair <code>`. Once everyone's in, run
+> `/discord:access policy allowlist` to lock it.
 
-### 7. Install the Discord channel plugin
-
-```bash
-claude plugin install discord@claude-plugins-official
-```
-
-### 8. Configure the Discord allowlist (security)
-
-This is critical. Without the allowlist, anyone who can message the bot can send
-instructions to the Claude Code session.
+### 9. Set up guild channel (optional)
 
 Tell the user:
 
-> To find your Discord user ID: In Discord with Developer Mode enabled,
-> click your username at the bottom left, then click **Copy User ID**.
-
-Guide the user to configure the allowlist so only their own Discord user ID can
-send messages. The exact command depends on the Discord channel plugin's interface —
-check its documentation for the allowlist or access policy setting.
+> For multi-agent collaboration, you'll want a shared guild channel that all
+> sessions can see. Get the channel ID by right-clicking the channel in Discord
+> (with Developer Mode enabled) and clicking **Copy Channel ID**.
+>
+> Then run:
+> ```
+> /discord:access group add <channel-id>
+> ```
+> Use `--no-mention` if you want the bot to see all messages (not just @mentions).
 
 Use AskUserQuestion:
-- "Have you configured the Discord allowlist with your user ID?"
-- Options: "Yes, allowlist configured" / "I need help finding my user ID" / "I'll do this later"
+- "Would you like to set up a guild channel now?"
+- Options: "Yes, I have the channel ID" / "No, DMs are enough for now"
 
-### 9. Restart with channels active
+If yes, guide them through the command.
 
-Tell the user:
-
-> To activate, restart Claude Code with:
-> ```
-> claude --channels plugin:discord@claude-plugins-official
-> ```
-> Claude will send a pairing code. Follow the prompts to pair your Discord account.
+### 10. Configure session name (optional)
 
-### 10. Test the setup
+The session name is used by the `/wr-connect:send` skill to identify this session
+in messages. Detect from git remote:
 
-Use AskUserQuestion:
-- "Would you like to send a test message to verify the setup?"
-- Options: "Yes, send a test" / "No, I'll test later"
+```bash
+git remote get-url origin 2>/dev/null | sed 's|.*github.com[:/]||;s|\.git$||'
+```
 
-If yes, tell them to use:
+If a `.env.tpl` exists in the project, check if `WR_CONNECT_SESSION_NAME` is defined.
+If not, suggest adding it:
 
 ```
-/wr-connect:send test message from setup
+WR_CONNECT_SESSION_NAME={{ op://Private/wr-connect/session_name }}
 ```
 
-Or from another terminal:
-
+Or for projects without 1Password, the session name can be set directly:
 ```bash
-curl -s -X POST "https://discord.com/api/v10/channels/$WR_CONNECT_CHANNEL_ID/messages" \
-  -H "Authorization: Bot $WR_CONNECT_BOT_TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{"content": "[wr-connect] from: test | setup verification"}'
+export WR_CONNECT_SESSION_NAME="<org/repo>"
 ```
 
-### 11. Explain collaboration behaviour
+### 11. Test the setup
+
+Use AskUserQuestion:
+- "Would you like to send a test message to verify everything works?"
+- Options: "Yes, send a test" / "No, I'll test later"
+
+If yes and a guild channel is set up, use the reply tool to send a message to
+the guild channel. If DM only, tell the user to DM the bot and check if it arrives.
+
+### 12. Explain collaboration behaviour
 
 Tell the user:
 
-> Your session is now part of a shared collaboration channel. Here's how it works:
+> Setup complete! Here's how collaboration works:
 >
-> - **Multiple sessions and humans** can share the same Discord channel.
+> - **Each repo has its own bot** — so you can see which session sent a message.
+> - **Multiple sessions and humans** can share the same guild channel.
 > - Use `@session-name` in messages to direct them at a specific session
 >   (e.g. `/wr-connect:send @repo-b please fix Widget.parse()`).
 > - Messages without `@` are broadcast — all sessions see them.
 > - Each session reads everything for context but only responds when the message
 >   is relevant to its work.
-> - Your session name is whatever you set in `WR_CONNECT_SESSION_NAME`. Other
->   sessions will use `@your-name` to get your attention.
 > - Agents can react to messages for lightweight acknowledgement.
+>
+> To set up another repo, install the wr-connect plugin there and run
+> `/wr-connect:setup` — it will create a new bot for that repo.
 
 $ARGUMENTS