claude-slack-channel-bots 0.2.1 → 0.4.0

package/README.md

@@ -39,8 +39,10 @@ See the sections below for manual configuration details if you prefer not to use
 - [Bun](https://bun.sh) v1.0+
 - [tmux](https://github.com/tmux/tmux) (required for server-managed sessions)
 - [Claude Code](https://claude.ai/code) installed and authenticated
+- `ss` from [iproute2](https://github.com/iproute2/iproute2) on your `PATH` (required for session ID discovery; pre-installed on most Linux distributions)
 - `curl` and `jq` on your `PATH` (required for the permission relay hooks)
 - Slack workspace admin access (to create and configure the Slack app)
+- **cozempic** (optional) — Python 3.10+ and `pip install cozempic` — enables session file cleaning before `--resume` for faster load times
 
 ---
 
@@ -91,7 +93,8 @@ A skeleton file is created by postinstall. Populate it before running `start`.
   "health_check_interval": 120,
   "exit_timeout": 120,
   "stop_timeout": 30,
-  "mcp_config_path": "~/.claude/slack-mcp.json"
+  "mcp_config_path": "~/.claude/slack-mcp.json",
+  "cozempic_prescription": "standard"
 }
 ```
 
@@ -110,6 +113,7 @@ 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. |
+| `cozempic_prescription` | string | `"standard"` | Cozempic cleaning intensity before resume. Valid values: `gentle`, `standard`, `aggressive`. Has no effect if cozempic is not installed. |
 
 ---
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-slack-channel-bots",
-  "version": "0.2.1",
-  "description": "Multi-session Slack-to-Claude bridge — run multiple Claude Code bots across Slack channels via Socket Mode",
+  "version": "0.4.0",
+  "description": "Multi-session Slack-to-Claude bridge \u2014 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

@@ -17,6 +17,7 @@ import { resolve } from 'path'
 // ---------------------------------------------------------------------------
 
 export const MCP_SERVER_NAME = 'slack-channel-router'
+export const ALLOWED_PRESCRIPTIONS = ['gentle', 'standard', 'aggressive']
 
 // ---------------------------------------------------------------------------
 // Types
@@ -41,6 +42,7 @@ export interface RoutingConfigInput {
   stop_timeout?: number
   mcp_config_path?: string
   append_system_prompt_file?: string
+  cozempic_prescription?: string
 }
 
 /** Validated, fully-resolved routing configuration with all defaults applied. */
@@ -56,6 +58,7 @@ export interface RoutingConfig {
   stop_timeout: number
   mcp_config_path: string
   append_system_prompt_file?: string
+  cozempic_prescription: string
 }
 
 // ---------------------------------------------------------------------------
@@ -79,6 +82,7 @@ export function applyDefaults(input: RoutingConfigInput): RoutingConfig {
     stop_timeout: input.stop_timeout ?? 30,
     mcp_config_path: input.mcp_config_path ?? '~/.claude/slack-mcp.json',
     append_system_prompt_file: input.append_system_prompt_file,
+    cozempic_prescription: input.cozempic_prescription ?? 'standard',
   }
 }
 
@@ -152,6 +156,13 @@ export function validateConfig(config: RoutingConfig): void {
     )
   }
 
+  // cozempic_prescription must be one of the allowed values
+  if (!ALLOWED_PRESCRIPTIONS.includes(config.cozempic_prescription)) {
+    throw new Error(
+      `Routing config validation error: cozempic_prescription "${config.cozempic_prescription}" is invalid. Allowed values are: ${ALLOWED_PRESCRIPTIONS.join(', ')}.`,
+    )
+  }
+
   // default_dm_session must reference an existing route CWD
   if (config.default_dm_session !== undefined) {
     if (!seen.has(config.default_dm_session)) {

package/src/cozempic.ts

@@ -0,0 +1,150 @@
+/**
+ * cozempic.ts — Session cleaning via the cozempic CLI.
+ *
+ * Provides PATH availability checking, JSONL path resolution, file size
+ * inspection, and async session cleaning using `cozempic treat`.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+import { spawn } from 'child_process'
+import { statSync } from 'fs'
+import { homedir } from 'os'
+import { ALLOWED_PRESCRIPTIONS } from './config.ts'
+
+// ---------------------------------------------------------------------------
+// PATH availability check
+// ---------------------------------------------------------------------------
+
+let cozempicAvailable: boolean | null = null
+
+/**
+ * Checks whether `cozempic` is on PATH by spawning `which cozempic`.
+ * Sets the module-scoped flag and logs the result to stderr.
+ */
+export async function checkCozempicAvailable(): Promise<void> {
+  return new Promise<void>((resolve) => {
+    let settled = false
+    const done = (available: boolean, msg: string) => {
+      if (settled) return
+      settled = true
+      cozempicAvailable = available
+      console.error(msg)
+      resolve()
+    }
+    const proc = spawn('which', ['cozempic'])
+    proc.on('error', () => {
+      done(false, '[slack] Warning: cozempic not found on PATH — session cleaning disabled')
+    })
+    proc.on('close', (code) => {
+      if (code === 0) {
+        done(true, '[slack] cozempic available')
+      } else {
+        done(false, '[slack] Warning: cozempic not found on PATH — session cleaning disabled')
+      }
+    })
+  })
+}
+
+/** Returns true if cozempic was found on PATH during the last availability check. */
+export function getCozempicAvailable(): boolean {
+  return cozempicAvailable === true
+}
+
+/** Resets the availability flag to null (for testing). */
+export function _resetCozempicAvailable(): void {
+  cozempicAvailable = null
+}
+
+// ---------------------------------------------------------------------------
+// JSONL path resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds the absolute JSONL path for a given cwd and session ID.
+ * Pure function — no I/O, no validation.
+ */
+export function resolveJsonlPath(cwd: string, sessionId: string): string {
+  const slug = cwd.replace(/[^a-zA-Z0-9-]/g, '-')
+  return `${homedir()}/.claude/projects/${slug}/${sessionId}.jsonl`
+}
+
+// ---------------------------------------------------------------------------
+// File size helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the size of the file at `path` in bytes, or null if the file
+ * cannot be stat'd (missing, permission error, etc.).
+ */
+export function readFileSizeBytes(path: string): number | null {
+  try {
+    return statSync(path).size
+  } catch {
+    return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Session cleaning
+// ---------------------------------------------------------------------------
+
+export type CleanSessionFn = (sessionId: string, cwd: string, prescription: string) => Promise<void>
+
+/**
+ * Runs `cozempic treat <sessionId> -rx <prescription> --execute` against the
+ * session's JSONL file. Always resolves — never rejects.
+ *
+ * Skips if the JSONL is missing or empty. Streams cozempic output to stderr
+ * with the `[slack] cozempic:` prefix and logs before/after file sizes.
+ */
+export async function cleanSession(sessionId: string, cwd: string, prescription: 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 beforeSize = readFileSizeBytes(path)
+
+  if (beforeSize === null) {
+    console.error(`[slack] cozempic: JSONL not found — skipping clean session=${sessionId}`)
+    return
+  }
+
+  if (beforeSize === 0) {
+    console.error(`[slack] cozempic: JSONL empty — skipping clean session=${sessionId}`)
+    return
+  }
+
+  console.error(`[slack] cozempic: cleaning started session=${sessionId} size=${beforeSize}`)
+
+  return new Promise<void>((resolve) => {
+    const proc = spawn('cozempic', ['treat', sessionId, '-rx', prescription, '--execute'])
+
+    proc.stdout.on('data', (chunk: Buffer) => {
+      for (const line of chunk.toString().split('\n')) {
+        if (line.length > 0) console.error(`[slack] cozempic: ${line}`)
+      }
+    })
+
+    proc.stderr.on('data', (chunk: Buffer) => {
+      for (const line of chunk.toString().split('\n')) {
+        if (line.length > 0) console.error(`[slack] cozempic: ${line}`)
+      }
+    })
+
+    proc.on('error', (err) => {
+      console.error(`[slack] cozempic: spawn error session=${sessionId}: ${err.message}`)
+      resolve()
+    })
+
+    proc.on('close', (code) => {
+      const afterSize = readFileSizeBytes(path)
+      if (code !== 0 && code !== null) {
+        console.error(`[slack] cozempic: exit code ${code} session=${sessionId}`)
+      }
+      console.error(`[slack] cozempic: cleaning done session=${sessionId} size=${afterSize ?? 'unknown'}`)
+      resolve()
+    })
+  })
+}

package/src/peer-pid.ts

@@ -0,0 +1,83 @@
+import { homedir } from 'os'
+import { join } from 'path'
+import { readFile } from 'fs/promises'
+
+// ---------------------------------------------------------------------------
+// getPeerPidByPort
+// ---------------------------------------------------------------------------
+
+/**
+ * Discover the PID of a process that has an established TCP connection
+ * from serverPort to peerPort on the loopback interface (IPv4 or IPv6).
+ *
+ * Runs: ss -tnp
+ * Filters for lines where local addr is 127.0.0.1:<serverPort> or ::1:<serverPort>
+ * and peer addr is 127.0.0.1:<peerPort> or ::1:<peerPort>.
+ *
+ * Returns the PID as a number, or null if not found or on any error.
+ */
+export async function getPeerPidByPort(
+  peerPort: number,
+  serverPort: number,
+): Promise<number | null> {
+  try {
+    const proc = Bun.spawn(['ss', '-tnp'], { stdout: 'pipe', stderr: 'pipe' })
+    const text = await new Response(proc.stdout).text()
+
+    for (const line of text.split('\n')) {
+      if (!matchesPorts(line, peerPort, serverPort)) continue
+      const pid = parsePid(line)
+      if (pid !== null) return pid
+    }
+    return null
+  } catch (err) {
+    console.error('[slack] peer-pid: getPeerPidByPort failed', err)
+    return null
+  }
+}
+
+/** Returns true if the ss output line matches the expected port pair on loopback. */
+function matchesPorts(line: string, peerPort: number, serverPort: number): boolean {
+  // ss -tnp columns: State Recv-Q Send-Q Local-Address:Port Peer-Address:Port ...
+  // Accept both 127.0.0.1 and ::1 loopback addresses.
+  const loopback = '(?:127\\.0\\.0\\.1|\\[?::1\\]?)'
+  const local = new RegExp(`${loopback}:${serverPort}(?:\\s|$)`)
+  const peer = new RegExp(`${loopback}:${peerPort}(?:\\s|$)`)
+  return local.test(line) && peer.test(line)
+}
+
+/**
+ * Parse PID from ss users field, e.g.:
+ *   users:(("bun",pid=12345,fd=7))
+ * Returns the PID as a number, or null if unparseable.
+ */
+function parsePid(line: string): number | null {
+  const m = line.match(/pid=(\d+)/)
+  if (!m) return null
+  const pid = parseInt(m[1], 10)
+  return isNaN(pid) ? null : pid
+}
+
+// ---------------------------------------------------------------------------
+// getSessionIdForPid
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the Claude Code session ID stored at ~/.claude/sessions/<pid>.json.
+ * Returns the sessionId string, or null if the file is missing, unreadable,
+ * or does not contain a valid sessionId string field.
+ *
+ * Never throws.
+ */
+export async function getSessionIdForPid(pid: number): Promise<string | null> {
+  try {
+    const filePath = join(homedir(), '.claude', 'sessions', `${pid}.json`)
+    const raw = await readFile(filePath, 'utf-8')
+    const parsed = JSON.parse(raw)
+    if (parsed && typeof parsed.sessionId === 'string') return parsed.sessionId
+    return null
+  } catch (err) {
+    console.error('[slack] peer-pid: getSessionIdForPid failed', err)
+    return null
+  }
+}

package/src/registry.ts

@@ -15,6 +15,8 @@ import {
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js'
 import { MCP_SERVER_NAME, type RoutingConfig } from './config.ts'
+import { getPeerPidByPort, getSessionIdForPid } from './peer-pid.ts'
+import { readSessions, writeSessions, type SessionsMap } from './sessions.ts'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -37,6 +39,12 @@ export interface SessionEntry {
   deliveredChannels: Set<string>
   /** Whether the session is currently connected (transport alive) */
   connected: boolean
+  /**
+   * TCP peer port of the most recent MCP request from this session.
+   * Updated per-request in server.ts before transport.handleRequest().
+   * Used by the CallToolRequestSchema handler to identify the calling process.
+   */
+  peerPort: number
 }
 
 /**
@@ -138,6 +146,7 @@ export function registerSession(
     server: resolvedServer,
     deliveredChannels,
     connected: true,
+    peerPort: 0,
   }
   registry.set(cwd, entry)
   return entry
@@ -323,6 +332,16 @@ export interface SessionToolDeps {
   resolveUserName: (userId: string) => Promise<string>
   /** Consume a pending ack entry — returns true if it existed */
   consumeAck: (channelId: string, messageTs: string) => boolean
+  /** TCP port the MCP HTTP server is listening on — used for peer PID discovery */
+  serverPort: number
+  /** Injectable for testing: replaces getPeerPidByPort in the discovery hook */
+  getPeerPidByPort?: (peerPort: number, serverPort: number) => Promise<number | null>
+  /** Injectable for testing: replaces getSessionIdForPid in the discovery hook */
+  getSessionIdForPid?: (pid: number) => Promise<string | null>
+  /** Injectable for testing: replaces readSessions in the discovery hook */
+  readSessions?: () => SessionsMap
+  /** Injectable for testing: replaces writeSessions in the discovery hook */
+  writeSessions?: (sessions: SessionsMap) => void
 }
 
 const MCP_INSTRUCTIONS = [
@@ -351,6 +370,10 @@ export function createSessionServer(
   deps: SessionToolDeps,
 ): Server {
   const { web, assertOutboundAllowed, assertSendable, getAccess, resolveUserName, inboxDir, consumeAck } = deps
+  const _getPeerPid = deps.getPeerPidByPort ?? getPeerPidByPort
+  const _getSessionId = deps.getSessionIdForPid ?? getSessionIdForPid
+  const _readSessions = deps.readSessions ?? readSessions
+  const _writeSessions = deps.writeSessions ?? writeSessions
 
   const server = new Server(
     { name: MCP_SERVER_NAME, version: '0.1.0' },
@@ -478,7 +501,8 @@ export function createSessionServer(
 
     const DEFAULT_CHUNK_LIMIT = 4000
 
-    switch (name) {
+    // Wrap switch in IIFE so we can trigger post-call discovery after the result is computed
+    const result = await (async () => { switch (name) {
       // ---------------------------------------------------------------------
       // reply
       // ---------------------------------------------------------------------
@@ -672,7 +696,36 @@ export function createSessionServer(
           content: [{ type: 'text', text: `Unknown tool: ${name}` }],
           isError: true,
         }
+    } })() // end IIFE
+
+    // -------------------------------------------------------------------------
+    // Post-call: fire-and-forget peer PID → session ID discovery (t2.nrd.so.a7)
+    // Never blocks or delays the tool call response.
+    // -------------------------------------------------------------------------
+    if (entry.peerPort > 0) {
+      const peerPort = entry.peerPort
+      const serverPort = deps.serverPort
+      const channelId = entry.channelId
+      ;(async () => {
+        try {
+          const pid = await _getPeerPid(peerPort, serverPort)
+          if (pid === null) return
+          const sessionId = await _getSessionId(pid)
+          if (!sessionId) return
+          const sessions = _readSessions()
+          const record = sessions[channelId]
+          if (!record) return
+          if (record.sessionId === sessionId) return
+          sessions[channelId] = { ...record, sessionId }
+          _writeSessions(sessions)
+          console.error(`[slack] peer-pid: updated sessionId for channel=${channelId} pid=${pid}`)
+        } catch (err) {
+          console.error('[slack] peer-pid: session discovery failed', err)
+        }
+      })()
     }
+
+    return result
   })
 
   return server

package/src/server.ts

@@ -42,6 +42,7 @@ import { loadConfig, expandTilde, type RoutingConfig, MCP_SERVER_NAME } from './
 import { readSessions, writeSessions, rotateSessions } from './sessions.ts'
 import { defaultTmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
 import { startupSessionManager, launchSession } from './session-manager.ts'
+import { cleanSession, getCozempicAvailable } from './cozempic.ts'
 import {
   initRestart,
   scheduleRestart,
@@ -106,6 +107,43 @@ const STATE_DIR = process.env['SLACK_STATE_DIR'] || join(homedir(), '.claude', '
 const ACCESS_FILE = join(STATE_DIR, 'access.json')
 const INBOX_DIR = join(STATE_DIR, 'inbox')
 const PID_FILE = join(STATE_DIR, 'server.pid')
+const KEEP_ALIVE_INTERVAL_MS = 30_000
+
+// ---------------------------------------------------------------------------
+// SSE keep-alive — prevents idle stream disconnection
+// ---------------------------------------------------------------------------
+
+const keepAliveTimers = new Map<WebStandardStreamableHTTPServerTransport, ReturnType<typeof setInterval>>()
+
+export function startSseKeepAlive(transport: WebStandardStreamableHTTPServerTransport): void {
+  const id = setInterval(() => {
+    const streamEntry = (transport as any)._streamMapping?.get('_GET_stream')
+    if (streamEntry?.controller && streamEntry?.encoder) {
+      try {
+        streamEntry.controller.enqueue(streamEntry.encoder.encode(':ping\n\n'))
+      } catch {
+        clearInterval(id)
+        keepAliveTimers.delete(transport)
+      }
+    }
+  }, KEEP_ALIVE_INTERVAL_MS)
+  keepAliveTimers.set(transport, id)
+}
+
+export function stopSseKeepAlive(transport: WebStandardStreamableHTTPServerTransport): void {
+  const id = keepAliveTimers.get(transport)
+  if (id !== undefined) {
+    clearInterval(id)
+    keepAliveTimers.delete(transport)
+  }
+}
+
+export function stopAllKeepAliveTimers(): void {
+  for (const id of keepAliveTimers.values()) {
+    clearInterval(id)
+  }
+  keepAliveTimers.clear()
+}
 
 // ---------------------------------------------------------------------------
 // Bootstrap — tokens & state directory
@@ -273,6 +311,7 @@ const sessionToolDeps: SessionToolDeps = {
   inboxDir: INBOX_DIR,
   resolveUserName,
   consumeAck,
+  serverPort: 0, // updated to actual port in main() before Bun.serve
 }
 
 // ---------------------------------------------------------------------------
@@ -298,6 +337,7 @@ function initPendingSession(): { pendingId: string; transport: WebStandardStream
     server: null as unknown as import('@modelcontextprotocol/sdk/server/index.js').Server,
     deliveredChannels,
     connected: true,
+    peerPort: 0,
   }
 
   const transport = new WebStandardStreamableHTTPServerTransport({
@@ -306,6 +346,7 @@ function initPendingSession(): { pendingId: string; transport: WebStandardStream
       // Transport-level init. Roots resolution happens via server.oninitialized.
     },
     onsessionclosed: (mcpSessionId) => {
+      stopSseKeepAlive(transport)
       // Session closed — clean up pending or registered state
       const pending = getPendingSession(mcpSessionId)
       if (pending) {
@@ -321,7 +362,8 @@ function initPendingSession(): { pendingId: string; transport: WebStandardStream
           : undefined
         if (channelId) {
           console.error(`[slack] Session disconnected: channel=${channelId} cwd="${cwd}"`)
-          scheduleRestart(channelId, cwd, readSessions()[channelId]?.sessionId)
+          const storedId = readSessions()[channelId]?.sessionId
+          scheduleRestart(channelId, cwd, storedId !== 'pending' ? storedId : undefined)
         } else {
           console.error(`[slack] Session disconnected: cwd="${cwd}"`)
         }
@@ -330,6 +372,7 @@ function initPendingSession(): { pendingId: string; transport: WebStandardStream
   })
 
   entryStub.transport = transport
+  startSseKeepAlive(transport)
 
   // Build the MCP server (closes over entryStub.deliveredChannels)
   const server = createSessionServer(entryStub, sessionToolDeps)
@@ -813,6 +856,7 @@ async function shutdown(signal: string): Promise<void> {
   shuttingDown = true
   stopHealthCheck()
   cancelAllRestartTimers()
+  stopAllKeepAliveTimers()
 
   console.error(`[slack] Received ${signal} — shutting down`)
 
@@ -915,6 +959,9 @@ export async function main(): Promise<void> {
   await socket.start()
   console.error('[slack] Socket Mode connected')
 
+  // Propagate resolved port to tool deps for peer PID discovery
+  sessionToolDeps.serverPort = mcpPort
+
   // -------------------------------------------------------------------------
   // HTTP server — single /mcp endpoint, roots-based session identity
   // -------------------------------------------------------------------------
@@ -1281,6 +1328,12 @@ export async function main(): Promise<void> {
         }
         // entry is non-null here (null means init request, but we have a session ID)
 
+        // Propagate peer port to registered sessions for tool call PID discovery
+        if (entry !== null && 'channelId' in entry) {
+          const remoteAddr = server.requestIP(req) as { address: string; port: number } | null
+          if (remoteAddr?.port) (entry as SessionEntry).peerPort = remoteAddr.port
+        }
+
         // For GET requests (SSE streams), attach an abort listener to detect
         // client disconnections. The MCP SDK's onsessionclosed only fires on
         // explicit HTTP DELETE, so silent TCP/tmux kills are never detected
@@ -1302,7 +1355,8 @@ export async function main(): Promise<void> {
               : undefined
             if (channelId) {
               console.error(`[slack] Session disconnected (SSE abort): channel=${channelId} cwd="${cwd}"`)
-              scheduleRestart(channelId, cwd, readSessions()[channelId]?.sessionId)
+              const storedId = readSessions()[channelId]?.sessionId
+              scheduleRestart(channelId, cwd, storedId !== 'pending' ? storedId : undefined)
             } else {
               console.error(`[slack] Session disconnected (SSE abort): cwd="${cwd}"`)
             }
@@ -1365,10 +1419,14 @@ export async function main(): Promise<void> {
     },
     launchSession: async (channelId, cwd, sessionId) => {
       if (!routingConfig) return false
-      const resolvedSessionId = sessionId ?? readSessions()[channelId]?.sessionId
+      const stored = sessionId ?? readSessions()[channelId]?.sessionId
+      // Treat "pending" as undefined — fall back to a fresh launch, not --resume
+      const resolvedSessionId = stored !== 'pending' ? stored : undefined
       const record = await launchSession(
         channelId, cwd, routingConfig, defaultTmuxClient,
-        resolvedSessionId !== undefined ? { sessionId: resolvedSessionId } : undefined,
+        resolvedSessionId !== undefined
+          ? { sessionId: resolvedSessionId, cleanSession: getCozempicAvailable() ? cleanSession : undefined }
+          : undefined,
       )
       if (record) {
         const sessions = readSessions()

package/src/session-manager.ts

@@ -9,12 +9,27 @@
  * SPDX-License-Identifier: MIT
  */
 
-import { readFileSync, accessSync, constants } from 'fs'
-import { homedir } from 'node:os'
-import { type TmuxClient, sessionName, isClaudeRunning, getClaudePid } from './tmux.ts'
+import { accessSync, existsSync, constants } from 'fs'
+import { type TmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
+import { type CleanSessionFn, checkCozempicAvailable, getCozempicAvailable, cleanSession as defaultCleanSession, resolveJsonlPath } from './cozempic.ts'
 import { type SessionsMap, type SessionRecord } from './sessions.ts'
 import { type RoutingConfig, MCP_SERVER_NAME } from './config.ts'
 
+// ---------------------------------------------------------------------------
+// JSONL existence helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true if the JSONL conversation file exists for the given session.
+ * The slug is computed from the CWD by replacing all non-alphanumeric-or-hyphen
+ * characters with hyphens, matching Claude's project directory naming.
+ */
+export function jsonlExistsForSession(cwd: string, sessionId: string): boolean {
+  if (!/^[a-zA-Z0-9_-]+$/.test(sessionId)) return false
+  const path = resolveJsonlPath(cwd, sessionId)
+  return existsSync(path)
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -24,6 +39,8 @@ export interface LaunchOptions {
   pollTimeout?: number
   /** Claude session UUID to resume. When provided, --resume <id> is appended to the CLI command. */
   sessionId?: string
+  /** Optional session cleaning function to run before --resume launches. */
+  cleanSession?: CleanSessionFn
 }
 
 export interface SessionStateResult {
@@ -78,9 +95,10 @@ export async function launchSession(
   const PROMPT_TEXT = 'I am using this for local development'
   const NO_CONVERSATION_TEXT = 'No conversation found'
 
-  // Inner helper: sends the launch command and polls for the safety prompt,
-  // then continues polling for Claude PID and session file discovery.
-  // Returns the discovered SessionRecord on success, or null on failure/timeout.
+  // Inner helper: sends the launch command and polls for the safety prompt.
+  // Returns a SessionRecord immediately after the safety prompt is acknowledged.
+  // Resume path: sessionId = safeResumeId. Fresh path: sessionId = "pending".
+  // Returns null on timeout (safety prompt never appeared) or capturePane failure.
   async function attemptLaunch(
     withResumeId: string | undefined,
     sessionName_: string,
@@ -101,7 +119,6 @@ export async function launchSession(
     console.error(`[slack] Claude launch command sent to session: ${sessionName_}`)
 
     let delay = POLL_START_MS
-    let promptAcknowledged = false
 
     while (Date.now() < launchDeadline) {
       await new Promise<void>((resolve) => setTimeout(resolve, delay))
@@ -115,46 +132,23 @@ export async function launchSession(
         return null
       }
 
-      if (!promptAcknowledged && pane.includes(PROMPT_TEXT)) {
-        await tmuxClient.sendKeys(sessionName_, 'Enter')
-        console.error(`[slack] Safety prompt acknowledged in session: ${sessionName_}`)
-        promptAcknowledged = true
-      }
-
       // Fast-fail: "No conversation found" means the resume failed
       if (pane.includes(NO_CONVERSATION_TEXT)) {
         console.error(`[slack] "No conversation found" detected — fast-fail resume for channel=${channelId}`)
         return 'NO_CONVERSATION' as unknown as SessionRecord
       }
 
-      // Try to discover session ID via PID
-      const pid = await getClaudePid(sessionName_, tmuxClient)
-      if (pid !== null) {
-        const sessionFilePath = `${homedir()}/.claude/sessions/${pid}.json`
-        try {
-          const raw = readFileSync(sessionFilePath, 'utf-8')
-          const entry = JSON.parse(raw)
-          if (
-            typeof entry === 'object' &&
-            entry !== null &&
-            typeof entry.sessionId === 'string' &&
-            entry.sessionId.length > 0
-          ) {
-            const foundId = entry.sessionId as string
-            console.error(`[slack] launchSession: discovered sessionId=${foundId} via PID=${pid} for channel=${channelId}`)
-            return {
-              tmuxSession: sessionName_,
-              lastLaunch: new Date().toISOString(),
-              sessionId: foundId,
-            }
-          }
-        } catch {
-          // Session file not yet written — keep polling
+      if (pane.includes(PROMPT_TEXT)) {
+        await tmuxClient.sendKeys(sessionName_, 'Enter')
+        console.error(`[slack] Safety prompt acknowledged in session: ${sessionName_}`)
+        return {
+          tmuxSession: sessionName_,
+          lastLaunch: new Date().toISOString(),
+          sessionId: safeResumeId ?? 'pending',
         }
       }
     }
 
-    console.error(`[slack] Timed out waiting for session ID for channel=${channelId}`)
     return null
   }
 
@@ -162,6 +156,11 @@ export async function launchSession(
   await tmuxClient.newSession(name, cwd)
   console.error(`[slack] Session created: ${name} (cwd="${cwd}")`)
 
+  // Clean JSONL before resuming (if a cleanSession fn was provided)
+  if (resumeSessionId && resumeSessionId !== 'pending' && options?.cleanSession) {
+    await options.cleanSession(resumeSessionId, cwd, routingConfig.cozempic_prescription)
+  }
+
   // Attempt launch (with --resume if sessionId provided)
   let result = await attemptLaunch(resumeSessionId, name)
 
@@ -234,6 +233,8 @@ export async function startupSessionManager(
 
   console.error(`[slack] startupSessionManager: storedSessions=${JSON.stringify(storedSessions)}`)
 
+  await checkCozempicAvailable()
+
   const routeEntries = Object.entries(routingConfig.routes)
   const concurrency = options?.concurrency ?? 3
   const startupTimeout = options?.startupTimeout ?? 60_000
@@ -256,41 +257,22 @@ export async function startupSessionManager(
 
       if (running) {
         // Branch 1: Reconnect — session live, send /mcp reconnect <server-name>
-        const reconnectSessionId = storedSessions[channelId]?.sessionId ?? 'none'
+        const storedId = storedSessions[channelId]?.sessionId
+        const reconnectSessionId = storedId ?? 'none'
         console.error(`[slack] startupSessionManager: branch=reconnect channel=${channelId} sessionId=${reconnectSessionId}`)
         console.error(`[slack] Session live — reconnecting MCP server "${MCP_SERVER_NAME}": channel=${channelId} session=${name}`)
         await tmuxClient.sendKeys(name, `/mcp reconnect ${MCP_SERVER_NAME}`, 'Enter')
 
-        // Discover session ID via PID-based file lookup
-        const pid = await getClaudePid(name, tmuxClient)
-        if (pid !== null) {
-          const sessionFilePath = `${homedir()}/.claude/sessions/${pid}.json`
-          try {
-            const raw = readFileSync(sessionFilePath, 'utf-8')
-            const entry = JSON.parse(raw)
-            if (
-              typeof entry === 'object' &&
-              entry !== null &&
-              typeof entry.sessionId === 'string' &&
-              entry.sessionId.length > 0
-            ) {
-              const foundId = entry.sessionId as string
-              console.error(`[slack] startupSessionManager: reconnect discovered sessionId=${foundId} via PID=${pid} for channel=${channelId} (${Date.now() - routeStart}ms)`)
-              resultMap.set(channelId, {
-                tmuxSession: name,
-                lastLaunch: new Date().toISOString(),
-                sessionId: foundId,
-              })
-              succeeded++
-              return
-            }
-          } catch {
-            console.error(`[slack] startupSessionManager: reconnect — could not read session file for PID=${pid} channel=${channelId}`)
-          }
-        } else {
-          console.error(`[slack] startupSessionManager: reconnect — no claude PID found for channel=${channelId}`)
-        }
-        failed++
+        // Use stored session ID; fall back to "pending" if absent or already pending.
+        // The tool call hook (Epic 1) will update it to the real ID on the next tool call.
+        const sessionId = (storedId && storedId !== 'pending') ? storedId : 'pending'
+        console.error(`[slack] startupSessionManager: reconnect using sessionId=${sessionId} for channel=${channelId} (${Date.now() - routeStart}ms)`)
+        resultMap.set(channelId, {
+          tmuxSession: name,
+          lastLaunch: new Date().toISOString(),
+          sessionId,
+        })
+        succeeded++
         return
       }
     }
@@ -309,17 +291,22 @@ export async function startupSessionManager(
     const effectiveTimeout = Math.min(options?.pollTimeout ?? 120_000, startupTimeout)
     const launchOpts = { ...options, pollTimeout: effectiveTimeout }
 
-    if (storedSessionId && storedSessionId !== 'pending') {
+    const shouldResume = !!(storedSessionId && storedSessionId !== 'pending' && jsonlExistsForSession(route.cwd, storedSessionId))
+    if (!shouldResume && storedSessionId && storedSessionId !== 'pending') {
+      console.error(`[slack] startupSessionManager: no JSONL for stored session — skipping resume: channel=${channelId} sessionId=${storedSessionId}`)
+    }
+
+    if (shouldResume) {
       // Branch 2: Resume — launch with stored session ID
       console.error(`[slack] startupSessionManager: branch=resume channel=${channelId} sessionId=${storedSessionId}`)
       console.error(`[slack] Dead/missing process with stored session ID — resuming: channel=${channelId} session=${name} sessionId=${storedSessionId}`)
       const record = await launchSession(
         channelId, route.cwd, routingConfig, tmuxClient,
-        { ...launchOpts, sessionId: storedSessionId },
+        { ...launchOpts, sessionId: storedSessionId, cleanSession: getCozempicAvailable() ? defaultCleanSession : undefined },
       )
       const elapsed = Date.now() - routeStart
       if (record !== null) {
-        console.error(`[slack] startupSessionManager: channel=${channelId} resumed in ${elapsed}ms`)
+        console.error(`[slack] startupSessionManager: channel=${channelId} resumed in ${elapsed}ms (storedId=${storedSessionId} discoveredId=${record.sessionId})`)
         resultMap.set(channelId, record)
         succeeded++
       } else {