claude-slack-channel-bots 0.4.2 → 0.5.1

package/README.md

@@ -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`.
 
@@ -105,7 +105,7 @@ A skeleton file is created by postinstall. Populate it before running `start`.
 
 | Field | Type | Default | Description |
 |---|---|---|---|
-| `routes` | object | required | Map of Slack channel ID → route entry. Each entry requires a `cwd` field: the working directory for that session. Used to identify sessions via `roots/list` after MCP handshake. `~` is expanded. Each `cwd` must be unique across all routes. |
+| `routes` | object | required | Map of Slack channel ID → route entry. Each entry requires a `cwd` field: the working directory for that session. Used to identify sessions via `roots/list` after MCP handshake. `~` is expanded. Each `cwd` must be unique across all routes. May also include an optional `claude_config_dir` string (see below). |
 | `default_route` | string | — | CWD path to use when a message arrives on a channel with no explicit entry in `routes`. Must match an existing route `cwd`. Channels that are in `routes` but whose session is not yet registered have their messages dropped — they do not fall back to `default_route`. |
 | `default_dm_session` | string | — | CWD path of the session that handles direct messages. Must match an existing route `cwd`. |
 | `bind` | string | `"127.0.0.1"` | Interface the HTTP server binds to. Use `"0.0.0.0"` to expose on all interfaces. |
@@ -116,15 +116,40 @@ 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. |
+| `message_archive_db` | string | — | Path to a SQLite DB where every inbound Slack message is archived in real time. Parent directories are created if missing; schema is initialized on first open. Compatible with the `archive-messages.py` backfill script — both can write concurrently. Feature is disabled when absent. |
+| `claude_config_dir` | string | — | Path to a Claude on-disk config directory. When set, managed sessions launch with `CLAUDE_CONFIG_DIR='<resolved-path>'` so the bot authenticates against a specific account. `~` is expanded and the path is resolved to absolute. Per-route `routes[id].claude_config_dir` overrides this top-level value for individual channels. When neither is set, Claude's own default applies. Must be non-empty when set. |
+| `resume_enabled` | boolean | `true` | When `false`, the session manager always performs a fresh Claude session launch instead of resuming, both on startup and on runtime auto-restart, even when a stored session ID exists. Disabling this skips the `--resume` flag entirely. Use this as a workaround if your Claude Code version crashes with "sandbox required but unavailable" on `--resume` (a known regression in v2.1.120). |
+
+#### Per-route `claude_config_dir` override
+
+When you want different bot sessions to authenticate as different Claude accounts (e.g. one channel runs as a personal Max account, another as a corporate account), set `claude_config_dir` on the individual route. Per-route values take priority over the top-level `claude_config_dir`; routes without their own override fall back to the top-level value.
+
+```json
+{
+  "routes": {
+    "C_PERSONAL": {
+      "cwd": "~/projects/alpha",
+      "claude_config_dir": "~/.claude-maxauth"
+    },
+    "C_CORPORATE": {
+      "cwd": "~/projects/beta"
+    }
+  },
+  "claude_config_dir": "~/.claude-corp"
+}
+```
+
+`C_PERSONAL` launches with the Max account; `C_CORPORATE` falls through to the top-level value and uses the corporate account. Use `claude auth login --claudeai` (or `--console`) with `CLAUDE_CONFIG_DIR` set to the same directory to populate each config dir before starting the server.
 
 ---
 
 ### 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 +178,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 +203,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 +220,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.
 
@@ -221,7 +246,7 @@ Gracefully exits all managed Claude Code sessions, then stops and starts the ser
 claude-slack-channel-bots clean_restart
 ```
 
-For each session in `sessions.json`, sends `/exit` to the tmux session and polls until Claude exits. All sessions are processed in parallel. If a session does not exit within `exit_timeout` seconds (default 120s), its tmux session is force-killed. Individual session errors are logged and do not abort the restart. After the server restarts, sessions are relaunched with `--resume` using the stored session IDs in `sessions.json`, preserving conversation context.
+For each session in `sessions.json`, sends `/exit` to the tmux session and polls until Claude exits. All sessions are processed in parallel. If a session does not exit within `exit_timeout` seconds (default 120s), its tmux session is force-killed. Individual session errors are logged and do not abort the restart. After the server restarts, sessions are relaunched using the stored session IDs in `sessions.json`. When `resume_enabled` is `true` (the default), sessions resume with `--resume`, preserving conversation context. When `resume_enabled` is `false`, sessions always launch fresh without `--resume`.
 
 Behavior by case:
 
@@ -270,17 +295,65 @@ Each MCP endpoint exposes the following tools to the connected Claude Code sessi
 
 ---
 
+## Interject
+
+POST to `/interject` to inject a message into an active Claude session from localhost. Only requests from `127.0.0.1` or `::1` are accepted — external callers are rejected with 403.
+
+### Request
+
+```sh
+curl -X POST http://localhost:<port>/interject \
+  -H "Content-Type: application/json" \
+  -d '{"channel": "C1234567890", "message": "Hello from a script", "sender": "my-cron-job"}'
+```
+
+| Field | Required | Description |
+|---|---|---|
+| `channel` | yes | Slack channel ID matching an entry in `config.json → routes`. |
+| `message` | yes | Text to inject into the session. |
+| `sender` | no | Label attached to the injected message. Defaults to `"interject"`. |
+
+### Response
+
+On success, returns HTTP 200:
+
+```json
+{ "ok": true, "channel": "C1234567890", "cwd": "/path/to/session" }
+```
+
+### Error conditions
+
+| Status | Meaning |
+|---|---|
+| 400 | Invalid JSON or missing required field (`channel` or `message`). |
+| 403 | Request did not originate from localhost. |
+| 404 | Channel not found in `config.json → routes`. |
+| 405 | Must use POST method. |
+| 413 | Request body exceeds 32KB. |
+| 503 | Channel is routed but no active session is connected. |
+
+### Example: crontab reminder
+
+```sh
+# crontab -e
+0 9 * * 1 curl -s -X POST http://localhost:3100/interject \
+  -H "Content-Type: application/json" \
+  -d '{"channel": "C1234567890", "message": "Weekly reminder: update the changelog before standup.", "sender": "cron"}'
+```
+
+---
+
 ## Permission Relay
 
 When Claude Code requires tool approval, the permission relay surfaces an interactive Slack message with **Allow** and **Deny** buttons instead of blocking the TUI. The Claude Code hook POSTs the pending request to the server, then long-polls for the user's response. Once the user clicks a button, the result is returned to Claude Code and execution continues.
 
 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**: they check the `CLAUDE_MANAGED_CHANNEL` environment variable, which is set as an inline env var (no `export`) on the `claude` command at launch. If the variable is absent, 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. If the variable is present but the server is unreachable, hooks fail closed (deny the tool call) to prevent indefinite hangs in headless sessions.
 
 Both hooks use a **two-phase long-poll protocol**:
 
-1. **Phase 1 — Create request:** The hook POSTs to `/permission` (or `/ask`) with the tool name, input, and CWD. The server posts an interactive Slack message and returns a `requestId`.
+1. **Phase 1 — Create request:** The hook POSTs to `/permission` (or `/ask`) with the tool name, input, and channel ID (from `$CLAUDE_MANAGED_CHANNEL`). The server posts an interactive Slack message and returns a `requestId`.
 2. **Phase 2 — Long-poll:** The hook GETs `/permission/{requestId}` (or `/ask/{requestId}`) in a loop with a 90-second `curl` timeout. The server holds the connection for up to 60 seconds waiting for a button click, then returns `{"status":"pending"}` if no decision has arrived. The hook retries immediately. Once the user clicks, the server returns `{"status":"decided","decision":"allow"|"deny"}` and the hook exits.
 
 ### Slack app prerequisites
@@ -328,7 +401,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 +414,33 @@ 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 check the `CLAUDE_MANAGED_CHANNEL` env var and exit silently if it is not set. Sessions launched manually will not have this variable and 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`.
+
+**Session crashes on resume with "sandbox required but unavailable"**
+This is a known regression in certain Claude Code releases (e.g. v2.1.120) where `--resume` triggers a sandbox check that fails in headless environments. Set `resume_enabled: false` in `config.json` to disable `--resume` entirely — the bot will always start a fresh Claude session instead of resuming a prior conversation, both on startup and on runtime auto-restart:
+
+```json
+{
+  "routes": { ... },
+  "resume_enabled": false
+}
+```

package/hooks/ask-relay.sh

@@ -2,10 +2,27 @@
 # AskUserQuestion relay — intercepts via PreToolUse, posts to Slack, returns answer
 set -euo pipefail
 
+# 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
-if [ -z "${SLACK_CHANNEL_BOT_SESSION:-}" ]; then
+if [ -z "${CLAUDE_MANAGED_CHANNEL:-}" ]; then
   exit 0
 fi
+CHANNEL="$CLAUDE_MANAGED_CHANNEL"
+
+deny_and_exit() {
+  printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny"}}\n'
+  exit 0
+}
 
 # Only handle AskUserQuestion
 INPUT=$(cat)
@@ -15,36 +32,32 @@ if [ "$TOOL_NAME" != "AskUserQuestion" ]; then
 fi
 
 # Extract question and options from tool input
-QUESTION=$(echo "$INPUT" | jq -r '.tool_input.question // ""' 2>/dev/null) || exit 0
-OPTIONS=$(echo "$INPUT" | jq -c '.tool_input.options // []' 2>/dev/null) || exit 0
-CWD=$(echo "$INPUT" | jq -r '.cwd // ""' 2>/dev/null) || exit 0
+QUESTION=$(echo "$INPUT" | jq -r '.tool_input.question // ""' 2>/dev/null) || deny_and_exit
+OPTIONS=$(echo "$INPUT" | jq -c '.tool_input.options // []' 2>/dev/null) || deny_and_exit
 
-if [ -z "$QUESTION" ] || [ "$OPTIONS" = "[]" ] || [ -z "$CWD" ]; then
-  exit 0
+if [ -z "$QUESTION" ] || [ "$OPTIONS" = "[]" ]; then
+  deny_and_exit
 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' \
-  -d "{\"question\":$(printf '%s' "$QUESTION" | jq -Rs .),\"options\":${OPTIONS},\"cwd\":$(printf '%s' "$CWD" | jq -Rs .)}" \
-  2>/dev/null) || exit 0
+  -d "{\"question\":$(printf '%s' "$QUESTION" | jq -Rs .),\"options\":${OPTIONS},\"channel\":$(printf '%s' "$CHANNEL" | jq -Rs .)}" \
+  2>/dev/null) || deny_and_exit
 
-REQUEST_ID=$(echo "$RESPONSE" | jq -r '.requestId // ""' 2>/dev/null) || exit 0
+REQUEST_ID=$(echo "$RESPONSE" | jq -r '.requestId // ""' 2>/dev/null) || deny_and_exit
 if [ -z "$REQUEST_ID" ]; then
-  exit 0
+  deny_and_exit
 fi
 
 # Phase 2: Long-poll for answer
 while true; do
-  POLL_RESPONSE=$(curl -s -f --max-time 90 "http://127.0.0.1:${PORT}/ask/${REQUEST_ID}" 2>/dev/null) || exit 0
+  POLL_RESPONSE=$(curl -s -f --max-time 90 "http://127.0.0.1:${PORT}/ask/${REQUEST_ID}" 2>/dev/null) || deny_and_exit
 
-  STATUS=$(echo "$POLL_RESPONSE" | jq -r '.status // ""' 2>/dev/null) || exit 0
+  STATUS=$(echo "$POLL_RESPONSE" | jq -r '.status // ""' 2>/dev/null) || deny_and_exit
 
   if [ "$STATUS" = "decided" ]; then
-    ANSWER=$(echo "$POLL_RESPONSE" | jq -r '.answer // ""' 2>/dev/null) || exit 0
+    ANSWER=$(echo "$POLL_RESPONSE" | jq -r '.answer // ""' 2>/dev/null) || deny_and_exit
     # Build the answers object: { "question text": "selected answer" }
     ANSWERS_JSON=$(jq -n --arg q "$QUESTION" --arg a "$ANSWER" '{($q): $a}')
     # Allow the tool and provide the answer via updatedInput

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,51 +10,62 @@ if ! command -v curl &>/dev/null; then
   exit 0
 fi
 
-# Read stdin
-INPUT=$(cat)
-
-# Extract fields from input
-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"
+# Read port from config.json, default to 3100
+CONFIG_FILE="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}/config.json"
 PORT=3100
-if [ -f "$ROUTING_FILE" ]; then
-  ROUTED_PORT=$(jq -r '.port // empty' "$ROUTING_FILE" 2>/dev/null) || true
+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
+if [ -z "${CLAUDE_MANAGED_CHANNEL:-}" ]; then
+  printf '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"deny","message":"Not a managed Slack session"}}}\n'
+  exit 0
+fi
+CHANNEL="$CLAUDE_MANAGED_CHANNEL"
+
+deny_and_exit() {
+  printf '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"deny","message":"%s"}}}\n' "$1"
+  exit 0
+}
+
+# Read stdin
+INPUT=$(cat)
+
+# Extract fields from input
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null) || deny_and_exit "Failed to parse tool_name"
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}' 2>/dev/null) || deny_and_exit "Failed to parse tool_input"
+
 BASE_URL="http://127.0.0.1:${PORT}"
 
 # Phase 1 — Create permission request
 PAYLOAD=$(jq -n \
   --arg tool_name "$TOOL_NAME" \
   --argjson tool_input "$TOOL_INPUT" \
-  --arg cwd "$CWD" \
-  '{tool_name: $tool_name, tool_input: $tool_input, cwd: $cwd}' 2>/dev/null) || exit 0
+  --arg channel "$CHANNEL" \
+  '{tool_name: $tool_name, tool_input: $tool_input, channel: $channel}' 2>/dev/null) || deny_and_exit "Failed to build payload"
 
 RESPONSE=$(curl -s -f -X POST \
   -H "Content-Type: application/json" \
   -d "$PAYLOAD" \
   --max-time 10 \
-  "${BASE_URL}/permission" 2>/dev/null) || exit 0
+  "${BASE_URL}/permission" 2>/dev/null) || deny_and_exit "Server unreachable"
 
-REQUEST_ID=$(echo "$RESPONSE" | jq -r '.requestId // ""' 2>/dev/null) || exit 0
+REQUEST_ID=$(echo "$RESPONSE" | jq -r '.requestId // ""' 2>/dev/null) || deny_and_exit "Failed to parse response"
 if [ -z "$REQUEST_ID" ]; then
-  exit 0
+  deny_and_exit "No requestId in server response"
 fi
 
 # Phase 2 — Long-poll loop (curl --max-time 90: 60s server hold + 30s buffer)
 while true; do
   POLL_RESPONSE=$(curl -s -f \
     --max-time 90 \
-    "${BASE_URL}/permission/${REQUEST_ID}" 2>/dev/null) || exit 0
+    "${BASE_URL}/permission/${REQUEST_ID}" 2>/dev/null) || deny_and_exit "Server connection lost"
 
-  STATUS=$(echo "$POLL_RESPONSE" | jq -r '.status // ""' 2>/dev/null) || exit 0
+  STATUS=$(echo "$POLL_RESPONSE" | jq -r '.status // ""' 2>/dev/null) || deny_and_exit "Failed to parse response"
 
   case "$STATUS" in
     "pending")
@@ -67,7 +73,7 @@ while true; do
       continue
       ;;
     "decided")
-      BEHAVIOR=$(echo "$POLL_RESPONSE" | jq -r '.decision // ""' 2>/dev/null) || exit 0
+      BEHAVIOR=$(echo "$POLL_RESPONSE" | jq -r '.decision // ""' 2>/dev/null) || deny_and_exit "Failed to parse decision"
       if [ "$BEHAVIOR" = "allow" ]; then
         printf '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow"}}}\n'
       else
@@ -76,8 +82,8 @@ while true; do
       exit 0
       ;;
     *)
-      # Unknown status — fall through to TUI
-      exit 0
+      # Unknown status — deny to fail closed
+      deny_and_exit "Unexpected poll status: $STATUS"
       ;;
   esac
 done

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-slack-channel-bots",
-  "version": "0.4.2",
-  "description": "Multi-session Slack-to-Claude bridge \u2014 run multiple Claude Code bots across Slack channels via Socket Mode",
+  "version": "0.5.1",
+  "description": "Multi-session Slack-to-Claude bridge — run multiple Claude Code bots across Slack channels via Socket Mode",
   "type": "module",
   "bin": {
     "claude-slack-channel-bots": "src/cli.ts"

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,7 +221,7 @@ 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.
 
@@ -230,7 +230,7 @@ their defaults unless asked.
 ### Step 5 — Configure custom system prompt for worker sessions
 
 Worker sessions launched by the server can receive a custom system prompt
-via `append_system_prompt_file` in `routing.json`. This controls how the
+via `append_system_prompt_file` in `config.json`. This controls how the
 bots behave — their role, communication style, and capabilities.
 
 **This is important.** Without a system prompt, bots won't know to communicate
@@ -275,7 +275,7 @@ Examples to offer if they're unsure:
    STATE_DIR="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}"
    ```
 
-3. Read `routing.json`, add or update:
+3. Read `config.json`, add or update:
    ```json
    "append_system_prompt_file": "~/.claude/channels/slack/system-prompt.md"
    ```
@@ -286,9 +286,22 @@ Examples to offer if they're unsure:
 
 **If the user explicitly skips:**
 
-Do not write `append_system_prompt_file` to `routing.json`, but warn them
+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"
+```
+
+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.
+
 ---
 
 ### Step 6 — Check access.json
@@ -437,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)
     }