claude-slack-channel-bots 0.0.4 → 0.1.1

package/README.md

@@ -105,6 +105,7 @@ A skeleton file is created by postinstall. Populate it before running `start`.
 | `session_restart_delay` | number | `60` | Seconds to wait before auto-restarting a dead session. Set to `0` to disable auto-restart. Must be non-negative. |
 | `health_check_interval` | number | `120` | Seconds between periodic liveness polls. Set to `0` to disable. Must be non-negative. |
 | `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. |
 
 ---
 
@@ -185,7 +186,7 @@ Checks prerequisites, then daemonizes the server.
 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.
 
-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`.
+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.
 
 ```
 [slack] Server starting in background (PID 12345)

package/package.json

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

package/skills/EXAMPLE_CLAUDE.md

@@ -0,0 +1,15 @@
+# Role
+You are an orchestration agent that bridges between the User and worker-Claude sessions you manage.
+
+# Communication with the User
+The User only communicate to you via Slack so 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
+
+# Development process
+You use the development process defined in the readme in ~/projects/apiary/README.MD.
+You use the Apiary skills listed in that project to manage software development from ideation to completion.
+
+# Spawning workers
+You do not do any work yourself, you always spawn Claude sessions as workers to do the work.
+This keeps you available to interact with the User and orchestrate the work.
+You use `waggle` to spawn workers and monitor their status.

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

@@ -225,7 +225,49 @@ their defaults unless asked.
 
 ---
 
-### Step 5 — Check access.json
+### Step 5 — Configure custom CLAUDE.md (optional)
+
+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.
+
+An example template is included with the package. Show the operator where it
+lives:
+
+```bash
+ls "$(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.
+
+Ask the operator: **"Do you want to configure a custom CLAUDE.md file for
+worker sessions?"**
+
+**If yes:**
+
+1. Prompt for the absolute path to their CLAUDE.md file.
+2. Verify the file exists:
+   ```bash
+   test -f "<provided-path>" && echo "ok" || echo "not found"
+   ```
+   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:
+   ```json
+   "append_system_prompt_file": "<provided-path>"
+   ```
+   Write the updated file, preserving all other fields.
+
+**If skipped:**
+
+Do not write `append_system_prompt_file` to `routing.json`. Move on.
+
+---
+
+### Step 6 — Check access.json
 
 ```bash
 STATE_DIR="${SLACK_STATE_DIR:-$HOME/.claude/channels/slack}"
@@ -264,7 +306,7 @@ Do not modify `access.json` during setup unless the user asks to.
 
 ---
 
-### Step 6 — Check hooks
+### Step 7 — Check hooks
 
 Check whether the relay hooks exist and are executable:
 
@@ -312,7 +354,7 @@ chmod +x ~/.claude/hooks/permission-relay.sh ~/.claude/hooks/ask-relay.sh
 
 ---
 
-### Step 7 — Check Claude Code settings.json for hook entries
+### Step 8 — Check Claude Code settings.json for hook entries
 
 Read `~/.claude/settings.json` and check whether the `PermissionRequest` and
 `PreToolUse` hook entries for the relay scripts are present.
@@ -365,13 +407,14 @@ If the user agrees, make the targeted edits, preserving all existing content.
 
 ---
 
-### Step 8 — Summary
+### Step 9 — Summary
 
 Print a final summary of what was checked and configured:
 
 - Environment variables: set / missing
 - Token format: valid / invalid
 - routing.json: populated (N routes) / skeleton
+- append_system_prompt_file: configured / skipped
 - access.json: present / missing
 - permission-relay.sh hook: present and executable / missing
 - ask-relay.sh hook: present and executable / missing

package/src/config.ts

@@ -12,6 +12,12 @@ import { readFileSync } from 'fs'
 import { homedir } from 'os'
 import { resolve } from 'path'
 
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+export const MCP_SERVER_NAME = 'slack-channel-router'
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -32,6 +38,7 @@ export interface RoutingConfigInput {
   session_restart_delay?: number
   health_check_interval?: number
   mcp_config_path?: string
+  append_system_prompt_file?: string
 }
 
 /** Validated, fully-resolved routing configuration with all defaults applied. */
@@ -44,6 +51,7 @@ export interface RoutingConfig {
   session_restart_delay: number
   health_check_interval: number
   mcp_config_path: string
+  append_system_prompt_file?: string
 }
 
 // ---------------------------------------------------------------------------
@@ -64,6 +72,7 @@ export function applyDefaults(input: RoutingConfigInput): RoutingConfig {
     session_restart_delay: input.session_restart_delay ?? 60,
     health_check_interval: input.health_check_interval ?? 120,
     mcp_config_path: input.mcp_config_path ?? '~/.claude/slack-mcp.json',
+    append_system_prompt_file: input.append_system_prompt_file,
   }
 }
 
@@ -160,6 +169,9 @@ export function resolveConfig(input: RoutingConfigInput): RoutingConfig {
       ? resolve(expandTilde(withDefaults.default_dm_session))
       : undefined,
     mcp_config_path: resolve(expandTilde(withDefaults.mcp_config_path)),
+    append_system_prompt_file: withDefaults.append_system_prompt_file !== undefined
+      ? resolve(expandTilde(withDefaults.append_system_prompt_file))
+      : undefined,
   }
 
   validateConfig(config)

package/src/postinstall.ts

@@ -13,6 +13,7 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import { homedir } from 'os'
 import { dirname, join } from 'path'
 import { defaultAccess } from './lib.ts'
+import { MCP_SERVER_NAME } from './config.ts'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -70,7 +71,7 @@ export function runPostinstall(options: PostinstallOptions = {}): void {
   } else {
     const skeleton = {
       mcpServers: {
-        'slack-channel-router': {
+        [MCP_SERVER_NAME]: {
           type: 'http',
           url: 'http://127.0.0.1:3100/mcp',
         },

package/src/registry.ts

@@ -14,7 +14,7 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js'
-import type { RoutingConfig } from './config.ts'
+import { MCP_SERVER_NAME, type RoutingConfig } from './config.ts'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -335,7 +335,7 @@ export function createSessionServer(
   const { web, assertOutboundAllowed, assertSendable, getAccess, resolveUserName, inboxDir, consumeAck } = deps
 
   const server = new Server(
-    { name: 'slack-channel-router', version: '0.1.0' },
+    { name: MCP_SERVER_NAME, version: '0.1.0' },
     {
       capabilities: {
         experimental: { 'claude/channel': {} },

package/src/restart.ts

@@ -14,7 +14,7 @@
 export interface RestartDeps {
   isSessionAlive(channelId: string): Promise<boolean>
   killSession(channelId: string): Promise<void>
-  launchSession(channelId: string, cwd: string): Promise<boolean>
+  launchSession(channelId: string, cwd: string, sessionId?: string): Promise<boolean>
   getRestartDelay(): number
   isShuttingDown(): boolean
 }
@@ -46,7 +46,7 @@ export function initRestart(d: RestartDeps): void {
 // scheduleRestart
 // ---------------------------------------------------------------------------
 
-export function scheduleRestart(channelId: string, cwd: string): void {
+export function scheduleRestart(channelId: string, cwd: string, sessionId?: string): void {
   if (!deps) {
     console.error('[slack] scheduleRestart: deps not initialized — skipping')
     return
@@ -109,7 +109,7 @@ export function scheduleRestart(channelId: string, cwd: string): void {
 
       let ok: boolean
       try {
-        ok = await deps.launchSession(channelId, cwd)
+        ok = await deps.launchSession(channelId, cwd, sessionId)
       } catch (err) {
         console.error(`[slack] restart: launchSession threw for channel=${channelId}:`, err)
         ok = false

package/src/server.ts

@@ -18,7 +18,7 @@ import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/
 import { SocketModeClient } from '@slack/socket-mode'
 import { WebClient } from '@slack/web-api'
 import { homedir } from 'os'
-import { join, resolve } from 'path'
+import { join, resolve, relative, isAbsolute } from 'path'
 import { fileURLToPath } from 'url'
 import {
   readFileSync,
@@ -37,7 +37,7 @@ import {
   type Access,
   type GateResult,
 } from './lib.ts'
-import { loadConfig, expandTilde, type RoutingConfig } from './config.ts'
+import { loadConfig, expandTilde, type RoutingConfig, MCP_SERVER_NAME } from './config.ts'
 import { readSessions, writeSessions } from './sessions.ts'
 import { defaultTmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
 import { startupSessionManager, launchSession } from './session-manager.ts'
@@ -73,6 +73,30 @@ import {
 // Re-export constants so they stay in one place (lib.ts)
 export { MAX_PENDING, MAX_PAIRING_REPLIES, PAIRING_EXPIRY_MS } from './lib.ts'
 
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Find the channel whose route CWD is the closest ancestor of (or equal to)
+ * the given absolute path. Returns undefined when no route matches.
+ */
+function findChannelByCwd(absoluteCwd: string, routes: RoutingConfig['routes']): string | undefined {
+  let bestChannel: string | undefined
+  let bestLen = -1
+  for (const [channelId, route] of Object.entries(routes)) {
+    const routeCwd = resolve(expandTilde(route.cwd))
+    const rel = relative(routeCwd, absoluteCwd)
+    if (rel === '' || (!rel.startsWith('..') && !isAbsolute(rel))) {
+      if (routeCwd.length > bestLen) {
+        bestLen = routeCwd.length
+        bestChannel = channelId
+      }
+    }
+  }
+  return bestChannel
+}
+
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -296,7 +320,7 @@ function initPendingSession(): { pendingId: string; transport: WebStandardStream
           : undefined
         if (channelId) {
           console.error(`[slack] Session disconnected: channel=${channelId} cwd="${cwd}"`)
-          scheduleRestart(channelId, cwd)
+          scheduleRestart(channelId, cwd, readSessions()[channelId]?.sessionId)
         } else {
           console.error(`[slack] Session disconnected: cwd="${cwd}"`)
         }
@@ -1003,12 +1027,10 @@ export async function main(): Promise<void> {
           )
         }
 
-        // Normalize CWD and find matching channel
+        // Find the most specific route whose CWD is an ancestor of (or equal to) the request CWD
         const normalizedCwd = resolve(expandTilde(cwd))
         const matchedChannelId = routingConfig
-          ? Object.entries(routingConfig.routes).find(
-              ([, route]) => resolve(expandTilde(route.cwd)) === normalizedCwd,
-            )?.[0]
+          ? findChannelByCwd(normalizedCwd, routingConfig.routes)
           : undefined
 
         if (!matchedChannelId) {
@@ -1150,11 +1172,10 @@ export async function main(): Promise<void> {
           )
         }
 
+        // Find the most specific route whose CWD is an ancestor of (or equal to) the request CWD
         const normalizedCwd = resolve(expandTilde(cwd as string))
         const matchedChannelId = routingConfig
-          ? Object.entries(routingConfig.routes).find(
-              ([, route]) => resolve(expandTilde(route.cwd)) === normalizedCwd,
-            )?.[0]
+          ? findChannelByCwd(normalizedCwd, routingConfig.routes)
           : undefined
 
         if (!matchedChannelId) {
@@ -1266,7 +1287,7 @@ export async function main(): Promise<void> {
               : undefined
             if (channelId) {
               console.error(`[slack] Session disconnected (SSE abort): channel=${channelId} cwd="${cwd}"`)
-              scheduleRestart(channelId, cwd)
+              scheduleRestart(channelId, cwd, readSessions()[channelId]?.sessionId)
             } else {
               console.error(`[slack] Session disconnected (SSE abort): cwd="${cwd}"`)
             }
@@ -1288,10 +1309,10 @@ export async function main(): Promise<void> {
   console.error(`[slack] MCP server listening on http://${mcpHost}:${mcpPort}/mcp`)
   console.error('')
   console.error('Save this to ~/.claude/slack-mcp.json:')
-  console.error(JSON.stringify({ mcpServers: { 'slack-channel-router': { type: 'http', url: `http://${mcpHost}:${mcpPort}/mcp` } } }, null, 2))
+  console.error(JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: { type: 'http', url: `http://${mcpHost}:${mcpPort}/mcp` } } }, null, 2))
   console.error('')
   console.error('Then launch Claude from a project directory with:')
-  console.error('  claude --mcp-config ~/.claude/slack-mcp.json --dangerously-load-development-channels server:slack-channel-router')
+  console.error(`  claude --mcp-config ~/.claude/slack-mcp.json --dangerously-load-development-channels server:${MCP_SERVER_NAME}`)
   console.error('')
 
   // Initialize restart module with adapters bridging tmux + session-manager
@@ -1311,9 +1332,13 @@ export async function main(): Promise<void> {
       const exists = await defaultTmuxClient.hasSession(name)
       if (exists) await defaultTmuxClient.killSession(name)
     },
-    launchSession: (channelId, cwd) => {
+    launchSession: (channelId, cwd, sessionId) => {
       if (!routingConfig) return Promise.resolve(false)
-      return launchSession(channelId, cwd, routingConfig, defaultTmuxClient, readSessions, writeSessions)
+      const resolvedSessionId = sessionId ?? readSessions()[channelId]?.sessionId
+      return launchSession(
+        channelId, cwd, routingConfig, defaultTmuxClient, readSessions, writeSessions,
+        resolvedSessionId !== undefined ? { sessionId: resolvedSessionId } : undefined,
+      )
     },
     getRestartDelay: () => routingConfig?.session_restart_delay ?? 60,
     isShuttingDown: () => shuttingDown,

package/src/session-manager.ts

@@ -1,16 +1,20 @@
 /**
  * session-manager.ts — Startup orchestration for tmux-managed Claude Code sessions.
  *
- * Handles two cases per route at server startup:
- *   exists  — tmux session found → kill and relaunch
- *   missing — no tmux session → launch fresh
+ * Handles three cases per route at server startup:
+ *   reconnect — tmux session exists AND Claude is running → send /mcp reconnect, do not relaunch
+ *   resume    — dead or missing process with stored session ID → kill stale session, relaunch with --resume
+ *   fresh     — dead or missing process without stored session ID → kill stale session, launch fresh
  *
  * SPDX-License-Identifier: MIT
  */
 
+import { readdirSync, readFileSync, accessSync, constants } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
 import { type TmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
 import { type SessionsMap } from './sessions.ts'
-import { type RoutingConfig } from './config.ts'
+import { type RoutingConfig, MCP_SERVER_NAME } from './config.ts'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -19,14 +23,63 @@ import { type RoutingConfig } from './config.ts'
 export interface LaunchOptions {
   /** Maximum time in ms to poll for the safety prompt. Default: 60000. */
   pollTimeout?: number
+  /** Claude session UUID to resume. When provided, --resume <id> is appended to the CLI command. */
+  sessionId?: string
 }
 
 export interface SessionStateResult {
   channelId: string
-  action: 'relaunched' | 'launched' | 'failed'
+  action: 'reconnected' | 'launched' | 'resumed' | 'failed'
   sessionName: string
 }
 
+// ---------------------------------------------------------------------------
+// Session ID capture helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Polls ~/.claude/sessions/ for a new session file matching the given CWD
+ * with a startedAt timestamp after `launchTimestamp`. Returns the sessionId
+ * string if found, or undefined if capture fails or times out.
+ *
+ * Polls up to ~2 seconds (4 × 500ms intervals).
+ */
+async function captureSessionId(cwd: string, launchTimestamp: number): Promise<string | undefined> {
+  const sessionsDir = join(homedir(), '.claude', 'sessions')
+  const POLL_INTERVAL_MS = 500
+  const POLL_ATTEMPTS = 4
+
+  for (let i = 0; i < POLL_ATTEMPTS; i++) {
+    await new Promise<void>((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+    try {
+      const files = readdirSync(sessionsDir)
+      for (const file of files) {
+        if (!file.endsWith('.json')) continue
+        try {
+          const raw = readFileSync(join(sessionsDir, file), 'utf-8')
+          const entry = JSON.parse(raw)
+          if (
+            typeof entry === 'object' &&
+            entry !== null &&
+            entry.cwd === cwd &&
+            typeof entry.startedAt === 'number' &&
+            entry.startedAt > launchTimestamp &&
+            typeof entry.sessionId === 'string' &&
+            entry.sessionId.length > 0
+          ) {
+            return entry.sessionId as string
+          }
+        } catch {
+          // skip unreadable or malformed files
+        }
+      }
+    } catch {
+      // sessionsDir may not exist yet; keep polling
+    }
+  }
+  return undefined
+}
+
 // ---------------------------------------------------------------------------
 // launchSession
 // ---------------------------------------------------------------------------
@@ -36,6 +89,10 @@ export interface SessionStateResult {
  * correct MCP config, polls for the safety prompt, and records the session
  * in sessions.json on success.
  *
+ * When options.sessionId is provided, appends --resume <id> to the CLI
+ * command. If the resume attempt fails, kills the tmux session and retries
+ * once with a fresh launch (no --resume).
+ *
  * Returns true on success, false on failure.
  */
 export async function launchSession(
@@ -49,64 +106,124 @@ export async function launchSession(
 ): Promise<boolean> {
   const name = sessionName(cwd)
   const pollTimeout = options?.pollTimeout ?? 60_000
+  const resumeSessionId = options?.sessionId
 
-  // Create detached tmux session with the channel's CWD
-  await tmuxClient.newSession(name, cwd)
-  console.error(`[slack] Session created: ${name} (cwd="${cwd}")`)
-
-  // Send the claude launch command, then Enter to execute it
   const escapedConfigPath = routingConfig.mcp_config_path.replace(/'/g, "'\\''")
-  const launchCmd = `claude --mcp-config '${escapedConfigPath}' --dangerously-load-development-channels server:slack-channel-router`
-  await tmuxClient.sendKeys(name, launchCmd)
-  await tmuxClient.sendKeys(name, 'Enter')
-  console.error(`[slack] Claude launch command sent to session: ${name}`)
+  let baseCmd = `claude --mcp-config '${escapedConfigPath}' --dangerously-load-development-channels server:${MCP_SERVER_NAME}`
+
+  if (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, "'\\''")
+      baseCmd += ` --append-system-prompt-file '${escapedPromptPath}'`
+    } catch {
+      // file missing or unreadable — skip
+    }
+  }
 
-  // Poll capturePane for the safety prompt with exponential backoff.
-  // Start at 500ms, double each iteration, cap at 5s, total limit 60s.
   const POLL_START_MS = 500
   const POLL_CAP_MS = 5_000
   const PROMPT_TEXT = 'I am using this for local development'
 
-  let delay = POLL_START_MS
-  const deadline = Date.now() + pollTimeout
+  // Inner helper: sends the launch command and polls for the safety prompt.
+  // Returns { ok: true, capturedId } on success (capturedId may be undefined if capture failed),
+  // or { ok: false } when Claude is not running after the poll timeout.
+  async function attemptLaunch(
+    withResumeId: string | undefined,
+  ): Promise<{ ok: true; capturedId: string | undefined } | { ok: false }> {
+    const safeResumeId = withResumeId && /^[a-zA-Z0-9_-]+$/.test(withResumeId) ? withResumeId : undefined
+    if (withResumeId && !safeResumeId) {
+      console.error(`[slack] Invalid session ID format — ignoring resume for channel=${channelId}`)
+    }
+    const launchTimestamp = Date.now()
+    const launchCmd = safeResumeId ? `${baseCmd} --resume ${safeResumeId}` : baseCmd
+    if (safeResumeId) {
+      console.error(`[slack] Attempting resume launch for channel=${channelId} sessionId=${safeResumeId}`)
+    } else {
+      console.error(`[slack] Attempting fresh launch for channel=${channelId}`)
+    }
+    await tmuxClient.sendKeys(name, launchCmd)
+    await tmuxClient.sendKeys(name, 'Enter')
+    console.error(`[slack] Claude launch command sent to session: ${name}`)
 
-  while (Date.now() < deadline) {
-    await new Promise<void>((resolve) => setTimeout(resolve, delay))
-    delay = Math.min(delay * 2, POLL_CAP_MS)
+    let delay = POLL_START_MS
+    const deadline = launchTimestamp + pollTimeout
 
-    let pane: string
-    try {
-      pane = await tmuxClient.capturePane(name)
-    } catch {
-      // capturePane failure is terminal — session may have died
-      break
+    while (Date.now() < deadline) {
+      await new Promise<void>((resolve) => setTimeout(resolve, delay))
+      delay = Math.min(delay * 2, POLL_CAP_MS)
+
+      let pane: string
+      try {
+        pane = await tmuxClient.capturePane(name)
+      } catch {
+        // capturePane failure is terminal — session may have died
+        break
+      }
+
+      if (pane.includes(PROMPT_TEXT)) {
+        await tmuxClient.sendKeys(name, 'Enter')
+        console.error(`[slack] Safety prompt acknowledged in session: ${name}`)
+        const capturedId = await captureSessionId(cwd, launchTimestamp)
+        if (capturedId) {
+          console.error(`[slack] Session ID captured for channel=${channelId}: ${capturedId}`)
+        } else {
+          console.error(`[slack] Session ID capture failed for channel=${channelId} — continuing without it`)
+        }
+        return { ok: true, capturedId }
+      }
     }
 
-    if (pane.includes(PROMPT_TEXT)) {
-      // Safety prompt found — acknowledge it and record success
-      await tmuxClient.sendKeys(name, 'Enter')
-      console.error(`[slack] Safety prompt acknowledged in session: ${name}`)
-      const sessions = readSessionsFn()
-      sessions[channelId] = { tmuxSession: name, lastLaunch: new Date().toISOString() }
-      writeSessionsFn(sessions)
-      console.error(`[slack] Session recorded in sessions.json: channel=${channelId}`)
-      return true
+    // Prompt not found — check if Claude is running anyway (forward-compatible)
+    const running = await isClaudeRunning(name, tmuxClient)
+    if (running) {
+      console.error(`[slack] Safety prompt not found but Claude is running — accepting session: ${name}`)
+      const capturedId = await captureSessionId(cwd, launchTimestamp)
+      if (capturedId) {
+        console.error(`[slack] Session ID captured for channel=${channelId}: ${capturedId}`)
+      } else {
+        console.error(`[slack] Session ID capture failed for channel=${channelId} — continuing without it`)
+      }
+      return { ok: true, capturedId }
     }
+
+    return { ok: false }
   }
 
-  // Prompt not found — check if Claude is running anyway (forward-compatible)
-  const running = await isClaudeRunning(name, tmuxClient)
-  if (running) {
-    console.error(`[slack] Safety prompt not found but Claude is running — accepting session: ${name}`)
-    const sessions = readSessionsFn()
-    sessions[channelId] = { tmuxSession: name, lastLaunch: new Date().toISOString() }
-    writeSessionsFn(sessions)
-    console.error(`[slack] Session recorded in sessions.json: channel=${channelId}`)
-    return true
+  // Create detached tmux session with the channel's CWD
+  await tmuxClient.newSession(name, cwd)
+  console.error(`[slack] Session created: ${name} (cwd="${cwd}")`)
+
+  // Attempt launch (with --resume if sessionId provided)
+  let result = await attemptLaunch(resumeSessionId)
+
+  // resumeSessionId was provided but launch failed — fall back to a fresh launch
+  if (!result.ok && resumeSessionId !== undefined) {
+    console.error(`[slack] Resume failed for channel=${channelId} — killing session and retrying with fresh launch`)
+    try {
+      await tmuxClient.killSession(name)
+    } catch {
+      // ignore kill errors; proceed with fresh session creation
+    }
+    await tmuxClient.newSession(name, cwd)
+    console.error(`[slack] Session recreated for fresh fallback: ${name} (cwd="${cwd}")`)
+    result = await attemptLaunch(undefined)
+  }
+
+  if (!result.ok) {
+    console.error(`[slack] Session launch failed — Claude not running in session: ${name}`)
+    return false
   }
 
-  console.error(`[slack] Session launch failed — Claude not running in session: ${name}`)
-  return false
+  const sessions = readSessionsFn()
+  sessions[channelId] = {
+    tmuxSession: name,
+    lastLaunch: new Date().toISOString(),
+    ...(result.capturedId !== undefined ? { sessionId: result.capturedId } : {}),
+  }
+  writeSessionsFn(sessions)
+  console.error(`[slack] Session recorded in sessions.json: channel=${channelId}`)
+  return true
 }
 
 // ---------------------------------------------------------------------------
@@ -114,9 +231,11 @@ export async function launchSession(
 // ---------------------------------------------------------------------------
 
 /**
- * On server startup, inspects all configured routes and takes action:
- *   - Exists (session found): kills session and relaunches
- *   - Missing: launches fresh
+ * On server startup, inspects all configured routes and takes action using a
+ * three-branch decision tree per route:
+ *   - Reconnect: tmux session exists AND Claude is running → send /mcp reconnect, do not relaunch
+ *   - Resume: dead or missing process with stored session ID → kill stale session, relaunch with --resume
+ *   - Fresh: dead or missing process without stored session ID → kill stale session, launch fresh
  *
  * Returns early with a warning if tmux is unavailable.
  */
@@ -138,6 +257,9 @@ export async function startupSessionManager(
 
   const results: SessionStateResult[] = []
 
+  // Load stored session IDs for all channels once before the route iteration loop
+  const storedSessions = readSessionsFn()
+
   for (const [channelId, route] of Object.entries(routingConfig.routes)) {
     const name = sessionName(route.cwd)
 
@@ -145,17 +267,38 @@ export async function startupSessionManager(
       const exists = await tmuxClient.hasSession(name)
 
       if (exists) {
-        // Session exists — kill and relaunch regardless of whether Claude is running
-        console.error(`[slack] Session exists — killing and relaunching: channel=${channelId} session=${name}`)
+        const running = await isClaudeRunning(name, tmuxClient)
+
+        if (running) {
+          // Branch 1: Reconnect — session live, send /mcp reconnect <server-name>
+          console.error(`[slack] Session live — reconnecting MCP server "${MCP_SERVER_NAME}": channel=${channelId} session=${name}`)
+          await tmuxClient.sendKeys(name, `/mcp reconnect ${MCP_SERVER_NAME}`)
+          await tmuxClient.sendKeys(name, 'Enter')
+          results.push({ channelId, action: 'reconnected', sessionName: name })
+          continue
+        }
+      }
+
+      // Branch 2 or 3: Dead or missing process — check for stored session ID
+      const storedSessionId = storedSessions[channelId]?.sessionId
+
+      if (exists) {
+        // Kill stale tmux session before relaunching
+        console.error(`[slack] Stale session found — killing before relaunch: channel=${channelId} session=${name}`)
         await tmuxClient.killSession(name)
+      }
+
+      if (storedSessionId) {
+        // Branch 2: Resume — launch with stored session ID
+        console.error(`[slack] Dead/missing process with stored session ID — resuming: channel=${channelId} session=${name} sessionId=${storedSessionId}`)
         const ok = await launchSession(
           channelId, route.cwd, routingConfig, tmuxClient,
-          readSessionsFn, writeSessionsFn, options,
+          readSessionsFn, writeSessionsFn, { ...options, sessionId: storedSessionId },
         )
-        results.push({ channelId, action: ok ? 'relaunched' : 'failed', sessionName: name })
+        results.push({ channelId, action: ok ? 'resumed' : 'failed', sessionName: name })
       } else {
-        // No session — launch fresh
-        console.error(`[slack] No session found — launching: channel=${channelId} session=${name}`)
+        // Branch 3: Fresh — launch without session ID
+        console.error(`[slack] No stored session ID — launching fresh: channel=${channelId} session=${name}`)
         const ok = await launchSession(
           channelId, route.cwd, routingConfig, tmuxClient,
           readSessionsFn, writeSessionsFn, options,

package/src/sessions.ts

@@ -23,6 +23,7 @@ import { expandTilde } from './config.ts'
 export interface SessionRecord {
   tmuxSession: string
   lastLaunch: string // ISO-8601, e.g. new Date().toISOString()
+  sessionId?: string // Claude session UUID, captured after launch
 }
 
 export type SessionsMap = Record<string, SessionRecord>