claude-slack-channel-bots 0.4.1 → 0.5.0

package/README.md

@@ -1,4 +1,4 @@
-# Slack Channel Router
+# Claude Slack Channel Bots
 
 A single HTTP MCP server that holds one Slack Socket Mode connection and routes messages to multiple independent Claude Code sessions, each scoped to a different repo and reachable via its own Slack channel. Inbound messages are dispatched to whichever session owns the channel they arrived on; outbound tool calls are restricted to channels that session has previously received a message from.
 
@@ -56,7 +56,7 @@ Tokens and runtime options are read from environment variables. There is no `.en
 |---|---|
 | `SLACK_BOT_TOKEN` | Slack bot token (`xoxb-…`). Required. Granted by the OAuth install flow. |
 | `SLACK_APP_TOKEN` | Slack app-level token (`xapp-…`). Required. Generated under Basic Information → App-Level Tokens with the `connections:write` scope. |
-| `SLACK_STATE_DIR` | Override the directory where `routing.json`, `access.json`, and runtime state are stored. Defaults to `~/.claude/channels/slack`. |
+| `SLACK_STATE_DIR` | Override the directory where `config.json`, `access.json`, and runtime state are stored. Defaults to `~/.claude/channels/slack`. |
 | `SLACK_ACCESS_MODE` | Set to `static` to load `access.json` once at startup and cache it for the lifetime of the process rather than re-reading it on every event. Useful in high-throughput environments where disk reads are a concern. |
 | `SLACK_DRY_RUN` | Set to `1` to start the server without Slack credentials. Token validation is skipped, Socket Mode and `web.auth.test()` are not called, and MCP tool calls (`reply`, `react`, etc.) are logged instead of sent. Useful for integration testing. |
 
@@ -74,9 +74,9 @@ export SLACK_DRY_RUN=1
 
 ---
 
-### Routing (routing.json)
+### Routing (config.json)
 
-`routing.json` is read from `~/.claude/channels/slack/routing.json` by default. Override the directory with `SLACK_STATE_DIR`.
+`config.json` is read from `~/.claude/channels/slack/config.json` by default. Override the directory with `SLACK_STATE_DIR`.
 
 A skeleton file is created by postinstall. Populate it before running `start`.
 
@@ -116,15 +116,16 @@ A skeleton file is created by postinstall. Populate it before running `start`.
 | `stop_timeout` | number | `30` | Seconds to wait for the server process to exit after `SIGTERM` before escalating to `SIGKILL`. |
 | `mcp_config_path` | string | `~/.claude/slack-mcp.json` | Path to the MCP config file passed to Claude Code when launching managed sessions. |
 | `append_system_prompt_file` | string | — | Path to a file appended to every managed session's system prompt via `--append-system-prompt-file`. Missing file silently skipped. See `skills/EXAMPLE_CLAUDE.md` for a template. |
+| `system_prompt_mode` | string | `"append"` | Controls how `append_system_prompt_file` is applied. `"append"`: the custom prompt file is appended on top of `CLAUDE.md` (default, current behavior). `"none"`: only `CLAUDE.md` is used; `append_system_prompt_file` is ignored even if set. Use `"none"` when the project's `CLAUDE.md` already contains everything the bot needs. |
 | `cozempic_prescription` | string | `"standard"` | Cozempic cleaning intensity before resume. Valid values: `gentle`, `standard`, `aggressive`. Has no effect if cozempic is not installed. |
 
 ---
 
 ### Access Control (access.json)
 
-`access.json` is read from `~/.claude/channels/slack/access.json` by default (same directory as `routing.json`). A skeleton file with defaults is created by postinstall. The file is written with `0600` permissions.
+`access.json` is read from `~/.claude/channels/slack/access.json` by default (same directory as `config.json`). A skeleton file with defaults is created by postinstall. The file is written with `0600` permissions.
 
-Channels in `routing.json` are automatically allowed — you do not need to list them here. The `channels` map is only needed for per-channel overrides like requiring @mentions or restricting which users can trigger the bot.
+Channels in `config.json` are automatically allowed — you do not need to list them here. The `channels` map is only needed for per-channel overrides like requiring @mentions or restricting which users can trigger the bot.
 
 The `slack-channel-access` skill manages pairings and allowlist entries at runtime.
 
@@ -153,7 +154,7 @@ The `slack-channel-access` skill manages pairings and allowlist entries at runti
 |---|---|---|---|
 | `dmPolicy` | `"pairing"` \| `"allowlist"` \| `"disabled"` | `"pairing"` | Controls who can DM the bot. `pairing`: unknown users receive a one-time code and are added to `allowFrom` after verification. `allowlist`: only users in `allowFrom` are accepted. `disabled`: all DMs are dropped. |
 | `allowFrom` | string[] | `[]` | Slack user IDs allowed to DM the bot unconditionally (regardless of `dmPolicy`). |
-| `channels` | object | `{}` | Optional per-channel overrides. Channels in `routing.json` are allowed automatically — only add entries here to customize behavior (e.g. require @mention or restrict users). Each entry is a `ChannelPolicy`. |
+| `channels` | object | `{}` | Optional per-channel overrides. Channels in `config.json` are allowed automatically — only add entries here to customize behavior (e.g. require @mention or restrict users). Each entry is a `ChannelPolicy`. |
 | `channels[id].requireMention` | boolean | `false` | When `true`, messages in that channel are only delivered if the bot is `@mentioned`. |
 | `channels[id].allowFrom` | string[] | `[]` | When non-empty, restricts delivery to the listed Slack user IDs for that channel. |
 | `pending` | object | `{}` | Managed by the server. Stores in-flight pairing codes indexed by code string. Do not edit manually. |
@@ -178,7 +179,7 @@ Claude Code sessions need a config file pointing at the MCP server. A skeleton i
 }
 ```
 
-If you changed `port` or `bind` in `routing.json`, update the `url` here to match. The server-managed session launcher uses `mcp_config_path` from `routing.json` to locate this file.
+If you changed `port` or `bind` in `config.json`, update the `url` here to match. The server-managed session launcher uses `mcp_config_path` from `config.json` to locate this file.
 
 ---
 
@@ -195,7 +196,7 @@ Checks prerequisites, then daemonizes the server.
 1. `tmux` is on `PATH` — fails with `missing prerequisite: tmux` if not found.
 2. `SLACK_BOT_TOKEN` is set — fails with `missing prerequisite: SLACK_BOT_TOKEN environment variable` if absent.
 3. `SLACK_APP_TOKEN` is set — fails with `missing prerequisite: SLACK_APP_TOKEN environment variable` if absent.
-4. `routing.json` exists at `STATE_DIR/routing.json` — fails with the full path if not found.
+4. `config.json` exists at `STATE_DIR/config.json` — fails with the full path if not found.
 
 If all checks pass, the parent process spawns a detached child process and exits immediately, printing the child PID. The child starts the server and writes its PID to `STATE_DIR/server.pid`. Conversation context is preserved across server restarts when possible.
 
@@ -276,7 +277,7 @@ When Claude Code requires tool approval, the permission relay surfaces an intera
 
 The `ask-relay.sh` hook intercepts `AskUserQuestion` tool calls via `PreToolUse`, posts the question and its options to Slack as interactive buttons, and waits for the user's selection. The answer is returned to Claude Code via `updatedInput` without blocking the TUI.
 
-Both hooks are **scope-guarded**: they check for the `SLACK_CHANNEL_BOT_SESSION` environment variable and exit immediately (no-op) if it is not set. The server sets this variable on every Claude session it launches. This means installing the hooks globally in `settings.json` is safe — they will not activate for Claude sessions you run outside the bot.
+Both hooks are **scope-guarded**: on each invocation they call the server's `GET /is-managed?pid=$PPID` endpoint to verify that the calling process belongs to a server-managed Claude session. If the server is not running or does not recognize the PID, the hooks exit silently (no-op). This means installing the hooks globally in `settings.json` is safe — they will not activate for Claude sessions you run outside the bot.
 
 Both hooks use a **two-phase long-poll protocol**:
 
@@ -328,7 +329,7 @@ To enable it: open your Slack app config → **Interactivity & Shortcuts** → t
 
    `permission-relay.sh` relays tool permission requests (Allow/Deny) to Slack via `PermissionRequest`. `ask-relay.sh` relays `AskUserQuestion` calls to Slack via `PreToolUse`, returning the user's selection without blocking the TUI.
 
-Both hooks auto-detect the server port from `routing.json`. They read `${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}/routing.json` and use the `port` field (defaulting to `3100`), so they stay in sync if you change the port in routing config.
+Both hooks auto-detect the server port from `config.json`. They read `${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}/config.json` and use the `port` field (defaulting to `3100`), so they stay in sync if you change the port in routing config.
 
 ### Setup skill
 
@@ -341,23 +342,23 @@ The `update-config` skill can automate hook installation. It copies or symlinks
 **Missing environment variables**
 `start` exits with `missing prerequisite: SLACK_BOT_TOKEN environment variable` or `SLACK_APP_TOKEN environment variable`. Export both tokens in your shell profile and open a new terminal before running `start`.
 
-**routing.json not found**
-`start` exits with `missing prerequisite: routing.json not found at <path>`. Run `bun postinstall.ts` to create a skeleton, or create the file manually. Verify `SLACK_STATE_DIR` matches the directory you populated.
+**config.json not found**
+`start` exits with `missing prerequisite: config.json not found at <path>`. Run `bun postinstall.ts` to create a skeleton, or create the file manually. Verify `SLACK_STATE_DIR` matches the directory you populated.
 
-**routing.json CWD mismatch**
-If a Claude Code session connects but immediately disconnects, the session's actual CWD does not match any `cwd` in `routing.json`. Confirm the session's working directory matches the entry exactly (after tilde expansion). Duplicate CWDs across multiple routes are rejected at startup.
+**config.json CWD mismatch**
+If a Claude Code session connects but immediately disconnects, the session's actual CWD does not match any `cwd` in `config.json`. Confirm the session's working directory matches the entry exactly (after tilde expansion). Duplicate CWDs across multiple routes are rejected at startup.
 
 **Bot not receiving messages in a new channel**
 After inviting the bot to a channel, Slack may not deliver messages until the bot is @mentioned for the first time. This is a Slack Socket Mode behavior — the first @mention activates event delivery for that channel. After that, all messages flow normally regardless of `requireMention` settings.
 
 **Channel not in access.json**
-Messages to channels not listed in `access.json → channels` and not present in `routing.json → routes` are silently dropped. Use the `claude-slack-channels-config` skill or edit `access.json` directly to add the channel ID with a `ChannelPolicy` entry.
+Messages to channels not listed in `access.json → channels` and not present in `config.json → routes` are silently dropped. Use the `claude-slack-channels-config` skill or edit `access.json` directly to add the channel ID with a `ChannelPolicy` entry.
 
 **Permission relay not working**
-Check that the Slack app has interactivity enabled (Interactivity & Shortcuts → toggle on). Verify `curl` and `jq` are on your `PATH`. Confirm the hook scripts are executable (`chmod +x`). If the port was changed in `routing.json`, ensure `SLACK_STATE_DIR` is set correctly so the hooks can read the updated port. If the hooks are silently doing nothing, confirm the session was launched by the server — the hooks only activate when `SLACK_CHANNEL_BOT_SESSION=1` is present in the environment. Sessions launched manually will not trigger the relay.
+Check that the Slack app has interactivity enabled (Interactivity & Shortcuts → toggle on). Verify `curl` and `jq` are on your `PATH`. Confirm the hook scripts are executable (`chmod +x`). If the port was changed in `config.json`, ensure `SLACK_STATE_DIR` is set correctly so the hooks can read the updated port. If the hooks are silently doing nothing, confirm the session was launched by the server — the hooks call `GET /is-managed?pid=$PPID` and exit silently if the server is unreachable or the PID is not recognized. Sessions launched manually will not trigger the relay.
 
 **Session not restarting after crash**
-After 3 consecutive launch failures for a route, auto-restart is suspended until the server is restarted. Restart the server with `claude-slack-channel-bots stop && claude-slack-channel-bots start`. To disable auto-restart entirely, set `session_restart_delay` to `0` in `routing.json`.
+After 3 consecutive launch failures for a route, auto-restart is suspended until the server is restarted. Restart the server with `claude-slack-channel-bots stop && claude-slack-channel-bots start`. To disable auto-restart entirely, set `session_restart_delay` to `0` in `config.json`.
 
 **Session stuck during clean_restart**
 If a session does not exit within `exit_timeout` seconds (default 120s), `clean_restart` force-kills its tmux session and proceeds. To manually recover, run `tmux kill-session -t <session-name>` for any remaining sessions, then `claude-slack-channel-bots stop && claude-slack-channel-bots start`.

package/hooks/ask-relay.sh

@@ -2,8 +2,20 @@
 # AskUserQuestion relay — intercepts via PreToolUse, posts to Slack, returns answer
 set -euo pipefail
 
-# Guard: only relay for bot-managed sessions
-if [ -z "${SLACK_CHANNEL_BOT_SESSION:-}" ]; then
+# Check dependencies (must be before guard since guard needs curl+jq)
+if ! command -v jq &>/dev/null; then
+  exit 0
+fi
+if ! command -v curl &>/dev/null; then
+  exit 0
+fi
+
+# Read port from config.json
+PORT=$(jq -r '.port // 3100' "${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}/config.json" 2>/dev/null) || PORT=3100
+
+# Guard: only relay for bot-managed sessions (server PID check)
+HTTP_STATUS=$(curl -sf -o /dev/null -w "%{http_code}" "http://127.0.0.1:${PORT}/is-managed?pid=$PPID" 2>/dev/null) || HTTP_STATUS="000"
+if [ "$HTTP_STATUS" != "200" ]; then
   exit 0
 fi
 
@@ -23,9 +35,6 @@ if [ -z "$QUESTION" ] || [ "$OPTIONS" = "[]" ] || [ -z "$CWD" ]; then
   exit 0
 fi
 
-# Read port from routing config
-PORT=$(jq -r '.port // 3100' "${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}/routing.json" 2>/dev/null) || PORT=3100
-
 # Phase 1: POST question to server
 RESPONSE=$(curl -s -f -X POST "http://127.0.0.1:${PORT}/ask" \
   -H 'Content-Type: application/json' \

package/hooks/permission-relay.sh

@@ -2,11 +2,6 @@
 # permission-relay.sh - Claude Code PermissionRequest hook
 # Implements two-phase long-poll to relay permission decisions via Slack channel server
 
-# Guard: only relay for bot-managed sessions
-if [ -z "${SLACK_CHANNEL_BOT_SESSION:-}" ]; then
-  exit 0
-fi
-
 # Check dependencies
 if ! command -v jq &>/dev/null; then
   exit 0
@@ -15,6 +10,22 @@ if ! command -v curl &>/dev/null; then
   exit 0
 fi
 
+# Read port from config.json, default to 3100
+CONFIG_FILE="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}/config.json"
+PORT=3100
+if [ -f "$CONFIG_FILE" ]; then
+  ROUTED_PORT=$(jq -r '.port // empty' "$CONFIG_FILE" 2>/dev/null) || true
+  if [ -n "${ROUTED_PORT:-}" ]; then
+    PORT="$ROUTED_PORT"
+  fi
+fi
+
+# Guard: only relay for bot-managed sessions (server PID check)
+HTTP_STATUS=$(curl -sf -o /dev/null -w "%{http_code}" "http://127.0.0.1:${PORT}/is-managed?pid=$PPID" 2>/dev/null) || HTTP_STATUS="000"
+if [ "$HTTP_STATUS" != "200" ]; then
+  exit 0
+fi
+
 # Read stdin
 INPUT=$(cat)
 
@@ -23,16 +34,6 @@ TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null) || exit 0
 TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}' 2>/dev/null) || exit 0
 CWD=$(echo "$INPUT" | jq -r '.cwd // ""' 2>/dev/null) || exit 0
 
-# Read port from routing.json, default to 3100
-ROUTING_FILE="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}/routing.json"
-PORT=3100
-if [ -f "$ROUTING_FILE" ]; then
-  ROUTED_PORT=$(jq -r '.port // empty' "$ROUTING_FILE" 2>/dev/null) || true
-  if [ -n "${ROUTED_PORT:-}" ]; then
-    PORT="$ROUTED_PORT"
-  fi
-fi
-
 BASE_URL="http://127.0.0.1:${PORT}"
 
 # Phase 1 — Create permission request

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slack-channel-bots",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Multi-session Slack-to-Claude bridge \u2014 run multiple Claude Code bots across Slack channels via Socket Mode",
   "type": "module",
   "bin": {

package/skills/claude-slack-channels-config/SKILL.md

@@ -33,7 +33,7 @@ message handling (ack reactions, chunking).
 ```bash
 STATE_DIR="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}"
 # access.json lives at $STATE_DIR/access.json
-# routing.json lives at $STATE_DIR/routing.json
+# config.json lives at $STATE_DIR/config.json
 ```
 
 Always resolve the state directory using `$SLACK_STATE_DIR` with fallback to
@@ -102,12 +102,12 @@ Parse `$ARGUMENTS` and execute the matching subcommand:
 
 ### `status`
 1. Load `access.json`
-2. Load `routing.json` from the same state directory
+2. Load `config.json` from the same state directory
 3. Display:
    - DM policy
    - Allowlisted user IDs
    - Opted-in channels with their policies, showing two categories:
-     - **Implicit** — channels present in `routing.json` routes (automatically opted-in)
+     - **Implicit** — channels present in `config.json` routes (automatically opted-in)
      - **Explicit** — channels configured in `access.json` channels (with their `requireMention` and `allowFrom` settings)
    - Pending pairings (code + sender ID + expiry)
    - Ack reaction setting (or "not set")

package/skills/setup-slack-channel-bots/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: setup-slack-channel-bots
-description: Interactive setup wizard for claude-slack-channel-bots — checks tokens, routing.json, access.json, hooks, and Claude Code settings
+description: Interactive setup wizard for claude-slack-channel-bots — checks tokens, config.json, access.json, hooks, and Claude Code settings
 version: 1.0.0
 author: Jeremy Longshore <jeremy@intentsolutions.io>
 license: MIT
@@ -122,14 +122,14 @@ want confirmation.
 
 ---
 
-### Step 4 — Check routing.json
+### Step 4 — Check config.json
 
 State directory defaults to `~/.claude/channels/slack/`. Respect
 `$SLACK_STATE_DIR` if set.
 
 ```bash
 STATE_DIR="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}"
-cat "$STATE_DIR/routing.json" 2>/dev/null || echo "NOT_FOUND"
+cat "$STATE_DIR/config.json" 2>/dev/null || echo "NOT_FOUND"
 ```
 
 **If the file does not exist:**
@@ -169,7 +169,7 @@ test -d "<expanded-path>" && echo "ok" || echo "not found"
 Expand `~` before checking. If the directory does not exist, warn the user and
 ask whether to proceed anyway or provide a different path.
 
-After collecting at least one route, write the updated `routing.json`.
+After collecting at least one route, write the updated `config.json`.
 
 **Important:** Remind the user to invite the bot to each channel they configured.
 In Slack, type `/invite @Claude Slack Channel Bots` in each channel (or whatever
@@ -210,7 +210,7 @@ either value:
 
 **Validation before writing:**
 
-Before writing `routing.json`, verify that any value supplied for
+Before writing `config.json`, verify that any value supplied for
 `default_route` or `default_dm_session` exactly matches one of the `cwd`
 values in `routes`. If a value does not match:
 
@@ -221,51 +221,86 @@ values in `routes`. If a value does not match:
 
 Only write the field once a valid value is confirmed.
 
-Write the final `routing.json` with only the fields the user explicitly set
+Write the final `config.json` with only the fields the user explicitly set
 (plus the required `routes`). Do not write optional fields the user left at
 their defaults unless asked.
 
 ---
 
-### Step 5 — Configure custom CLAUDE.md (optional)
+### Step 5 — Configure custom system prompt for worker sessions
 
-Worker sessions launched by the server can receive a custom system-prompt
-append via `append_system_prompt_file` in `routing.json`. This is useful for
-giving all workers project-specific instructions: communication rules,
-development process, how to spawn sub-workers, and so on.
+Worker sessions launched by the server can receive a custom system prompt
+via `append_system_prompt_file` in `config.json`. This controls how the
+bots behave — their role, communication style, and capabilities.
 
-An example template is included with the package. Show the operator where it
-lives:
+**This is important.** Without a system prompt, bots won't know to communicate
+via Slack and will try to use the TUI (which nobody can see).
+
+An example template is included with the package. Read it for reference:
 
 ```bash
-ls "$(npm root -g)/claude-slack-channel-bots/skills/EXAMPLE_CLAUDE.md" 2>/dev/null \
+cat "$(npm root -g)/claude-slack-channel-bots/skills/EXAMPLE_CLAUDE.md" 2>/dev/null \
   || echo "NOT_FOUND"
 ```
 
-If the file is found, print its path so the operator can inspect it as a
-starting point.
+Show the user the example content so they understand what a system prompt
+looks like.
+
+Then ask: **"What should your bots do? Describe the role you want them to
+play, how they should communicate, and any specific behaviors."**
 
-Ask the operator: **"Do you want to configure a custom CLAUDE.md file for
-worker sessions?"**
+Examples to offer if they're unsure:
+- "I want a coding assistant that responds to my messages in Slack"
+- "I want an orchestrator that manages workers and reports status"
+- "I want a simple bot that answers questions about my codebase"
 
-**If yes:**
+**After the user describes what they want:**
 
-1. Prompt for the absolute path to their CLAUDE.md file.
-2. Verify the file exists:
+1. Write a system prompt file based on their description. The file MUST
+   always include these two essential sections at the top (adapt the wording
+   to match their described role):
+
+   ```markdown
+   # Communication with the User
+   The User communicates with you via Slack. Always use the
+   mcp__slack-channel-router__reply tool to send messages.
+   **Important**: Nothing you send to the TUI will be seen by the User.
+   ```
+
+   Then add sections based on what the user described (role, process,
+   capabilities, tone, etc.).
+
+2. Save the file to `~/.claude/channels/slack/system-prompt.md`:
    ```bash
-   test -f "<provided-path>" && echo "ok" || echo "not found"
+   STATE_DIR="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}"
    ```
-   Expand `~` before checking. If the file does not exist, warn the operator
-   and re-prompt until a valid path is given or they choose to skip.
-3. Read `routing.json`, add or update the top-level field:
+
+3. Read `config.json`, add or update:
    ```json
-   "append_system_prompt_file": "<provided-path>"
+   "append_system_prompt_file": "~/.claude/channels/slack/system-prompt.md"
    ```
    Write the updated file, preserving all other fields.
 
-**If skipped:**
+4. Show the user what was written and ask if they want to make changes.
+   Iterate until they're happy.
+
+**If the user explicitly skips:**
+
+Do not write `append_system_prompt_file` to `config.json`, but warn them
+that bots won't know to communicate via Slack without a system prompt.
+
+If the project's `CLAUDE.md` already contains all the instructions the bot
+needs (including Slack communication directives), the user can opt out of a
+separate prompt file by setting `system_prompt_mode: "none"` in `config.json`:
+
+```json
+"system_prompt_mode": "none"
+```
 
-Do not write `append_system_prompt_file` to `routing.json`. Move on.
+With this setting, `append_system_prompt_file` is ignored even if present, and
+only `CLAUDE.md` is used. This is the recommended approach when the bot's
+behavior is fully defined in the project's `CLAUDE.md` and a separate
+`system-prompt.md` would be redundant.
 
 ---
 
@@ -415,7 +450,7 @@ Print a final summary of what was checked and configured:
 
 - Environment variables: set / missing
 - Token format: valid / invalid
-- routing.json: populated (N routes) / skeleton
+- config.json: populated (N routes) / skeleton
 - append_system_prompt_file: configured / skipped
 - access.json: present / missing
 - permission-relay.sh hook: present and executable / missing

package/src/cli.ts

@@ -105,11 +105,11 @@ export function createCli(deps: CliDeps): CliHandlers {
       }
     }
 
-    // Check routing.json exists
+    // Check config.json exists
     const stateDir = deps.resolveStateDir()
-    const routingJson = join(stateDir, 'routing.json')
+    const routingJson = join(stateDir, 'config.json')
     if (!deps.existsSync(routingJson)) {
-      console.error(`missing prerequisite: routing.json not found at ${routingJson}`)
+      console.error(`missing prerequisite: config.json not found at ${routingJson}`)
       deps.exit(1)
     }
 

package/src/config.ts

@@ -18,6 +18,7 @@ import { resolve } from 'path'
 
 export const MCP_SERVER_NAME = 'slack-channel-router'
 export const ALLOWED_PRESCRIPTIONS = ['gentle', 'standard', 'aggressive']
+export const ALLOWED_SYSTEM_PROMPT_MODES = ['append', 'none']
 
 // ---------------------------------------------------------------------------
 // Types
@@ -27,7 +28,7 @@ export interface RouteEntry {
   cwd: string
 }
 
-/** Raw shape of routing.json as parsed from disk. All optional fields may be absent. */
+/** Raw shape of config.json as parsed from disk. All optional fields may be absent. */
 export interface RoutingConfigInput {
   routes: Record<string, RouteEntry>
   /** CWD path to use when a message arrives on a channel with no explicit entry in routes. */
@@ -43,6 +44,7 @@ export interface RoutingConfigInput {
   mcp_config_path?: string
   append_system_prompt_file?: string
   cozempic_prescription?: string
+  system_prompt_mode?: string
 }
 
 /** Validated, fully-resolved routing configuration with all defaults applied. */
@@ -59,6 +61,7 @@ export interface RoutingConfig {
   mcp_config_path: string
   append_system_prompt_file?: string
   cozempic_prescription: string
+  system_prompt_mode: string
 }
 
 // ---------------------------------------------------------------------------
@@ -83,6 +86,7 @@ export function applyDefaults(input: RoutingConfigInput): RoutingConfig {
     mcp_config_path: input.mcp_config_path ?? '~/.claude/slack-mcp.json',
     append_system_prompt_file: input.append_system_prompt_file,
     cozempic_prescription: input.cozempic_prescription ?? 'standard',
+    system_prompt_mode: input.system_prompt_mode ?? 'append',
   }
 }
 
@@ -163,6 +167,13 @@ export function validateConfig(config: RoutingConfig): void {
     )
   }
 
+  // system_prompt_mode must be one of the allowed values
+  if (!ALLOWED_SYSTEM_PROMPT_MODES.includes(config.system_prompt_mode)) {
+    throw new Error(
+      `Routing config validation error: system_prompt_mode "${config.system_prompt_mode}" is invalid. Allowed values are: ${ALLOWED_SYSTEM_PROMPT_MODES.join(', ')}.`,
+    )
+  }
+
   // default_dm_session must reference an existing route CWD
   if (config.default_dm_session !== undefined) {
     if (!seen.has(config.default_dm_session)) {
@@ -213,14 +224,14 @@ export function resolveConfig(input: RoutingConfigInput): RoutingConfig {
 // I/O wrapper
 // ---------------------------------------------------------------------------
 
-const DEFAULT_CONFIG_PATH = '~/.claude/channels/slack/routing.json'
+const DEFAULT_CONFIG_PATH = '~/.claude/channels/slack/config.json'
 
 /**
  * Reads routing configuration from disk, parses it, and returns a validated
  * RoutingConfig. Throws a descriptive error for missing files, malformed JSON,
  * or validation failures.
  *
- * @param path  Path to routing.json. Defaults to ~/.claude/channels/slack/routing.json.
+ * @param path  Path to config.json. Defaults to ~/.claude/channels/slack/config.json.
  */
 export function loadConfig(path?: string): RoutingConfig {
   const configPath = resolve(expandTilde(path ?? DEFAULT_CONFIG_PATH))

package/src/lib.ts

@@ -179,7 +179,7 @@ export interface GateOptions {
   /** Current bot user ID for mention detection */
   botUserId: string
   /**
-   * Set of channel IDs from routing.json. Any channel in this set is
+   * Set of channel IDs from config.json. Any channel in this set is
    * implicitly opted-in even if it has no entry in access.json's channels map.
    * access.json entries still take precedence for per-channel overrides.
    */
@@ -189,8 +189,8 @@ export interface GateOptions {
 export async function gate(event: unknown, opts: GateOptions): Promise<GateResult> {
   const ev = event as Record<string, unknown>
 
-  // 1. Drop bot messages immediately
-  if (ev['bot_id']) return { action: 'drop' }
+  // 1. Drop our own bot messages (but allow messages from other bots)
+  if (ev['bot_id'] && ev['user'] === opts.botUserId) return { action: 'drop' }
 
   // 2. Drop non-message subtypes (message_changed, message_deleted, etc.)
   if (ev['subtype'] && ev['subtype'] !== 'file_share') return { action: 'drop' }
@@ -244,7 +244,7 @@ export async function gate(event: unknown, opts: GateOptions): Promise<GateResul
   // 5. Channel handling — opt-in per channel ID
   //
   // A channel is allowed if it has an explicit entry in access.json OR if it
-  // appears in routing.json (routeChannels). Channels in routing.json are
+  // appears in config.json (routeChannels). Channels in config.json are
   // implicitly opted-in; access.json entries provide per-channel overrides
   // (requireMention, allowFrom). If neither applies, drop.
   const channel = ev['channel'] as string

package/src/postinstall.ts

@@ -3,13 +3,14 @@
  * postinstall.ts — Scaffold skeleton config files for the Slack Channel Router.
  *
  * Creates STATE_DIR and the MCP config parent if missing, then writes
- * routing.json, access.json, and slack-mcp.json only when they do not
+ * config.json, access.json, and slack-mcp.json only when they do not
  * already exist.  Safe to re-run: existing files are never modified.
+ * Migrates routing.json → config.json if the old file is present.
  *
  * SPDX-License-Identifier: MIT
  */
 
-import { existsSync, mkdirSync, writeFileSync, symlinkSync, readlinkSync, unlinkSync } from 'fs'
+import { existsSync, mkdirSync, writeFileSync, symlinkSync, readlinkSync, unlinkSync, renameSync } from 'fs'
 import { homedir } from 'os'
 import { dirname, join, resolve } from 'path'
 import { defaultAccess } from './lib.ts'
@@ -43,13 +44,20 @@ export function runPostinstall(options: PostinstallOptions = {}): void {
   mkdirSync(stateDir, { recursive: true })
   mkdirSync(dirname(mcpConfigPath), { recursive: true })
 
-  // routing.json
-  const routingPath = join(stateDir, 'routing.json')
-  if (existsSync(routingPath)) {
-    console.log(`skipped: ${routingPath}`)
+  // config.json — migrate from routing.json if needed
+  const configPath = join(stateDir, 'config.json')
+  const legacyPath = join(stateDir, 'routing.json')
+  if (existsSync(legacyPath) && !existsSync(configPath)) {
+    renameSync(legacyPath, configPath)
+    console.log(`Migrated routing.json → config.json`)
+  }
+
+  // Create skeleton config.json if neither old nor new file exists
+  if (existsSync(configPath)) {
+    console.log(`skipped: ${configPath}`)
   } else {
-    writeFileSync(routingPath, JSON.stringify({ routes: {} }, null, 2) + '\n')
-    console.log(`created: ${routingPath}`)
+    writeFileSync(configPath, JSON.stringify({ routes: {} }, null, 2) + '\n')
+    console.log(`created: ${configPath}`)
   }
 
   // access.json (permissions 0o600)

package/src/server.ts

@@ -40,7 +40,7 @@ import {
 } from './lib.ts'
 import { loadConfig, expandTilde, type RoutingConfig, MCP_SERVER_NAME } from './config.ts'
 import { readSessions, writeSessions, rotateSessions } from './sessions.ts'
-import { defaultTmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
+import { defaultTmuxClient, sessionName, isClaudeRunning, getClaudePid } from './tmux.ts'
 import { startupSessionManager, launchSession } from './session-manager.ts'
 import { cleanSession, getCozempicAvailable } from './cozempic.ts'
 import {
@@ -912,7 +912,7 @@ process.on('SIGINT',  () => { shutdown('SIGINT').catch(() => process.exit(1)) })
 //
 // All Claude Code sessions point to the same URL: http://<host>:<port>/mcp
 // Route assignment happens after the MCP initialized notification when the
-// server calls roots/list and matches the CWD against routing.json.
+// server calls roots/list and matches the CWD against config.json.
 // ---------------------------------------------------------------------------
 
 export async function main(): Promise<void> {
@@ -1003,6 +1003,7 @@ export async function main(): Promise<void> {
           // Already decided — return immediately
           const existingDecision = completedDecisions.get(pollRequestId)
           if (existingDecision !== undefined) {
+            completedDecisions.delete(pollRequestId)
             return new Response(JSON.stringify({ status: 'decided', decision: existingDecision }), {
               status: 200,
               headers: { 'Content-Type': 'application/json' },
@@ -1058,6 +1059,7 @@ export async function main(): Promise<void> {
             })
           }
 
+          completedDecisions.delete(pollRequestId)
           return new Response(JSON.stringify({ status: 'decided', decision }), {
             status: 200,
             headers: { 'Content-Type': 'application/json' },
@@ -1169,6 +1171,7 @@ export async function main(): Promise<void> {
 
           const existingAnswer = completedAnswers.get(pollRequestId)
           if (existingAnswer !== undefined) {
+            completedAnswers.delete(pollRequestId)
             return new Response(JSON.stringify({ status: 'decided', answer: existingAnswer }), {
               status: 200,
               headers: { 'Content-Type': 'application/json' },
@@ -1215,6 +1218,7 @@ export async function main(): Promise<void> {
           })
 
           if (answer !== null) {
+            completedAnswers.delete(pollRequestId)
             return new Response(JSON.stringify({ status: 'decided', answer }), {
               status: 200,
               headers: { 'Content-Type': 'application/json' },
@@ -1319,6 +1323,44 @@ export async function main(): Promise<void> {
         })
       }
 
+      // /is-managed — PID-based session membership check for hook guards
+      if (url.pathname === '/is-managed') {
+        if (req.method !== 'GET') {
+          return new Response('Method Not Allowed', { status: 405 })
+        }
+        // Validate localhost
+        const remoteAddr = server.requestIP(req)
+        const remoteHost = remoteAddr?.address ?? ''
+        if (remoteHost !== '127.0.0.1' && remoteHost !== '::1' && !remoteHost.startsWith('::ffff:127.')) {
+          return new Response('Forbidden', { status: 403 })
+        }
+        const pidStr = url.searchParams.get('pid')
+        const pid = pidStr ? parseInt(pidStr, 10) : NaN
+        if (isNaN(pid) || pid <= 0) {
+          return new Response(JSON.stringify({ error: 'Missing or invalid pid parameter' }), {
+            status: 400,
+            headers: { 'Content-Type': 'application/json' },
+          })
+        }
+        // Check all configured routes
+        if (routingConfig) {
+          for (const [, route] of Object.entries(routingConfig.routes)) {
+            const name = sessionName(route.cwd)
+            const claudePid = await getClaudePid(name, defaultTmuxClient)
+            if (claudePid === pid) {
+              return new Response(JSON.stringify({ managed: true }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+              })
+            }
+          }
+        }
+        return new Response(JSON.stringify({ managed: false }), {
+          status: 404,
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }
+
       // Only /mcp is the MCP endpoint — everything else is a 404
       if (url.pathname !== '/mcp') {
         return new Response(

package/src/session-manager.ts

@@ -14,6 +14,7 @@ import { type TmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
 import { type CleanSessionFn, checkCozempicAvailable, getCozempicAvailable, cleanSession as defaultCleanSession, resolveJsonlPath } from './cozempic.ts'
 import { type SessionsMap, type SessionRecord } from './sessions.ts'
 import { type RoutingConfig, MCP_SERVER_NAME } from './config.ts'
+import { isDryRun } from './tokens.ts'
 
 // ---------------------------------------------------------------------------
 // JSONL existence helper
@@ -78,9 +79,13 @@ export async function launchSession(
   const resumeSessionId = options?.sessionId
 
   const escapedConfigPath = routingConfig.mcp_config_path.replace(/'/g, "'\\''")
-  let baseCmd = `SLACK_CHANNEL_BOT_SESSION=1 claude --mcp-config '${escapedConfigPath}' --dangerously-load-development-channels server:${MCP_SERVER_NAME}`
+  // In dry-run mode, skip --dangerously-load-development-channels (requires OAuth which isn't
+  // available in Docker/CI). MCP still connects via --mcp-config; only channel routing is lost.
+  let baseCmd = isDryRun()
+    ? `claude --mcp-config '${escapedConfigPath}'`
+    : `claude --mcp-config '${escapedConfigPath}' --dangerously-load-development-channels server:${MCP_SERVER_NAME}`
 
-  if (routingConfig.append_system_prompt_file !== undefined) {
+  if (routingConfig.system_prompt_mode === 'append' && routingConfig.append_system_prompt_file !== undefined) {
     try {
       accessSync(routingConfig.append_system_prompt_file, constants.R_OK)
       const escapedPromptPath = routingConfig.append_system_prompt_file.replace(/'/g, "'\\''")
@@ -147,6 +152,18 @@ export async function launchSession(
           sessionId: safeResumeId ?? 'pending',
         }
       }
+
+      // If trust was pre-accepted (e.g. in Docker CI), Claude skips the safety
+      // prompt and goes straight to the ready prompt. Detect the Claude Code
+      // welcome banner which appears when Claude is fully loaded and ready.
+      if (pane.includes('Claude Code v') && pane.includes('❯')) {
+        console.error(`[slack] Claude ready (no safety prompt) in session: ${sessionName_}`)
+        return {
+          tmuxSession: sessionName_,
+          lastLaunch: new Date().toISOString(),
+          sessionId: safeResumeId ?? 'pending',
+        }
+      }
     }
 
     return null