claude-slack-channel-bots 0.5.0 → 0.5.1

package/README.md

@@ -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. |
@@ -118,6 +118,30 @@ A skeleton file is created by postinstall. Populate it before running `start`.
 | `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.
 
 ---
 
@@ -222,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:
 
@@ -271,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**: 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 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
@@ -355,10 +427,20 @@ After inviting the bot to a channel, Slack may not deliver messages until the bo
 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 `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.
+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 `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

@@ -13,11 +13,16 @@ 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
+# Guard: only relay for bot-managed sessions
+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)
@@ -27,33 +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
 
 # 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

@@ -20,19 +20,24 @@ if [ -f "$CONFIG_FILE" ]; then
   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
+# 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) || 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
+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}"
 
@@ -40,27 +45,27 @@ BASE_URL="http://127.0.0.1:${PORT}"
 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")
@@ -68,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
@@ -77,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.5.0",
-  "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/src/config.ts

@@ -26,6 +26,15 @@ export const ALLOWED_SYSTEM_PROMPT_MODES = ['append', 'none']
 
 export interface RouteEntry {
   cwd: string
+  /**
+   * Optional path to a Claude on-disk config directory for this route.
+   * When set, sessions for this route launch with `CLAUDE_CONFIG_DIR=<path>`,
+   * letting different routes authenticate against different Claude accounts.
+   * `~` is expanded and the path is resolved to absolute. When omitted, the
+   * top-level `claude_config_dir` is used (and Claude's own default applies
+   * if neither is set).
+   */
+  claude_config_dir?: string
 }
 
 /** Raw shape of config.json as parsed from disk. All optional fields may be absent. */
@@ -45,6 +54,21 @@ export interface RoutingConfigInput {
   append_system_prompt_file?: string
   cozempic_prescription?: string
   system_prompt_mode?: string
+  /** Optional path to a SQLite DB where every inbound Slack message will be archived. */
+  message_archive_db?: string
+  /**
+   * Top-level Claude on-disk config directory for routes that do not specify
+   * their own `claude_config_dir`. When set, managed sessions launch with
+   * `CLAUDE_CONFIG_DIR=<path>`. When omitted, Claude's own default applies.
+   * `~` is expanded and the path is resolved to absolute.
+   */
+  claude_config_dir?: string
+  /**
+   * When false, disables --resume on startup so bots always launch fresh.
+   * Defaults to true. Set to false to work around `--resume` regressions
+   * (e.g. Claude Code v2.1.120 "sandbox required but unavailable").
+   */
+  resume_enabled?: boolean
 }
 
 /** Validated, fully-resolved routing configuration with all defaults applied. */
@@ -62,6 +86,11 @@ export interface RoutingConfig {
   append_system_prompt_file?: string
   cozempic_prescription: string
   system_prompt_mode: string
+  /** Absolute path to SQLite archive DB. Undefined disables the feature. */
+  message_archive_db?: string
+  claude_config_dir?: string
+  /** When false, --resume is skipped on startup and bots always launch fresh. Defaults to true. */
+  resume_enabled: boolean
 }
 
 // ---------------------------------------------------------------------------
@@ -87,6 +116,9 @@ export function applyDefaults(input: RoutingConfigInput): RoutingConfig {
     append_system_prompt_file: input.append_system_prompt_file,
     cozempic_prescription: input.cozempic_prescription ?? 'standard',
     system_prompt_mode: input.system_prompt_mode ?? 'append',
+    message_archive_db: input.message_archive_db,
+    claude_config_dir: input.claude_config_dir,
+    resume_enabled: input.resume_enabled ?? true,
   }
 }
 
@@ -182,6 +214,26 @@ export function validateConfig(config: RoutingConfig): void {
       )
     }
   }
+
+  // Top-level claude_config_dir, when set, must be a non-empty (post-trim) string
+  if (config.claude_config_dir !== undefined) {
+    if (typeof config.claude_config_dir !== 'string' || config.claude_config_dir.trim() === '') {
+      throw new Error(
+        'Routing config validation error: claude_config_dir must be a non-empty string when set.',
+      )
+    }
+  }
+
+  // Per-route claude_config_dir, when set, must also be a non-empty (post-trim) string
+  for (const [channelId, route] of Object.entries(config.routes)) {
+    if (route.claude_config_dir !== undefined) {
+      if (typeof route.claude_config_dir !== 'string' || route.claude_config_dir.trim() === '') {
+        throw new Error(
+          `Routing config validation error: routes["${channelId}"].claude_config_dir must be a non-empty string when set.`,
+        )
+      }
+    }
+  }
 }
 
 /**
@@ -191,11 +243,20 @@ export function validateConfig(config: RoutingConfig): void {
 export function resolveConfig(input: RoutingConfigInput): RoutingConfig {
   const withDefaults = applyDefaults(input)
 
-  // Expand tildes on every route's cwd
+  // Expand tildes on every route's cwd and claude_config_dir; preserve other fields verbatim.
+  // Empty/whitespace claude_config_dir is preserved unchanged so validateConfig can reject it.
   const expandedRoutes: Record<string, RouteEntry> = {}
   for (const [channelId, entry] of Object.entries(withDefaults.routes)) {
     expandedRoutes[channelId] = {
+      ...entry,
       cwd: resolve(expandTilde(entry.cwd)),
+      ...(entry.claude_config_dir !== undefined
+        ? {
+            claude_config_dir: entry.claude_config_dir.trim() === ''
+              ? entry.claude_config_dir
+              : resolve(expandTilde(entry.claude_config_dir)),
+          }
+        : {}),
     }
   }
 
@@ -214,6 +275,14 @@ export function resolveConfig(input: RoutingConfigInput): RoutingConfig {
     append_system_prompt_file: withDefaults.append_system_prompt_file !== undefined
       ? resolve(expandTilde(withDefaults.append_system_prompt_file))
       : undefined,
+    message_archive_db: withDefaults.message_archive_db !== undefined
+      ? resolve(expandTilde(withDefaults.message_archive_db))
+      : undefined,
+    claude_config_dir: withDefaults.claude_config_dir !== undefined
+      ? (withDefaults.claude_config_dir.trim() === ''
+          ? withDefaults.claude_config_dir
+          : resolve(expandTilde(withDefaults.claude_config_dir)))
+      : undefined,
   }
 
   validateConfig(config)

package/src/cozempic.ts

@@ -63,10 +63,17 @@ export function _resetCozempicAvailable(): void {
 /**
  * Builds the absolute JSONL path for a given cwd and session ID.
  * Pure function — no I/O, no validation.
+ *
+ * When `configDir` is provided, the path is rooted at `${configDir}/projects/...`.
+ * This is used by managed bots launched with a custom `CLAUDE_CONFIG_DIR`,
+ * since Claude writes JSONL transcripts under that directory rather than
+ * `${homedir()}/.claude`. When omitted, falls back to the default
+ * `${homedir()}/.claude/projects/...` location.
  */
-export function resolveJsonlPath(cwd: string, sessionId: string): string {
+export function resolveJsonlPath(cwd: string, sessionId: string, configDir?: string): string {
   const slug = cwd.replace(/[^a-zA-Z0-9-]/g, '-')
-  return `${homedir()}/.claude/projects/${slug}/${sessionId}.jsonl`
+  const root = configDir ?? `${homedir()}/.claude`
+  return `${root}/projects/${slug}/${sessionId}.jsonl`
 }
 
 // ---------------------------------------------------------------------------
@@ -89,7 +96,7 @@ export function readFileSizeBytes(path: string): number | null {
 // Session cleaning
 // ---------------------------------------------------------------------------
 
-export type CleanSessionFn = (sessionId: string, cwd: string, prescription: string) => Promise<void>
+export type CleanSessionFn = (sessionId: string, cwd: string, prescription: string, configDir?: string) => Promise<void>
 
 /**
  * Runs `cozempic treat <sessionId> -rx <prescription> --execute` against the
@@ -97,13 +104,19 @@ export type CleanSessionFn = (sessionId: string, cwd: string, prescription: stri
  *
  * Skips if the JSONL is missing or empty. Streams cozempic output to stderr
  * with the `[slack] cozempic:` prefix and logs before/after file sizes.
+ *
+ * When `configDir` is provided, resolves the JSONL path under
+ * `${configDir}/projects/...` rather than the default `${homedir()}/.claude/...`.
+ * This is required for managed bots launched with a custom `CLAUDE_CONFIG_DIR`,
+ * since Claude writes its transcripts under that directory. Without it,
+ * cleaning before a `--resume` silently no-ops because the JSONL lookup misses.
  */
-export async function cleanSession(sessionId: string, cwd: string, prescription: string): Promise<void> {
+export async function cleanSession(sessionId: string, cwd: string, prescription: string, configDir?: string): Promise<void> {
   if (!ALLOWED_PRESCRIPTIONS.includes(prescription)) {
     console.error(`[slack] cozempic: invalid prescription "${prescription}" — skipping clean session=${sessionId}`)
     return
   }
-  const path = resolveJsonlPath(cwd, sessionId)
+  const path = resolveJsonlPath(cwd, sessionId, configDir)
   const beforeSize = readFileSizeBytes(path)
 
   if (beforeSize === null) {