@leviyuan/lodestar 0.1.0 → 2.0.14

package/daemon.ts

@@ -1,203 +1,1139 @@
 #!/usr/bin/env bun
 /**
- * Lodestar 2.0 daemon — Feishu (Lark) ↔ Claude Code headless bridge.
+ * Feishu daemon for DeepSeek TUI — standalone process that watches all
+ * Feishu groups and routes messages to/from DeepSeek via Runtime API.
  *
- * Listens on Lark WebSocket for inbound messages and card-action
- * callbacks, routes each to a per-chat Session that owns a headless
- * `claude` subprocess and a streaming Card Kit card.
+ * "hi"      → create or check a Runtime API thread
+ * "restart" → interrupt + fork (fresh context)
+ * "kill"    → archive thread
+ * "clear"   → compact thread
+ * "ls"      → render a tree of the project directory
+ * other     → inject as a turn into the thread
  *
- * Run:   bun daemon.ts
- * Stop:  SIGTERM
+ * Run: bun daemon.ts
+ *
+ * Design doc: LODESTAR_DEEPSEEK_DESIGN.md
  */
 
+import './env-bootstrap' // MUST be first
+
 import * as lark from '@larksuiteoapi/node-sdk'
-import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
-import { dirname } from 'node:path'
-import { Session } from './src/session'
-import * as feishu from './src/feishu'
-import { config } from './src/config'
-import { log } from './src/log'
-import { PID_FILE } from './src/paths'
-
-// ── PID guard ───────────────────────────────────────────────────────────
-try {
-  const existing = readFileSync(PID_FILE, 'utf8').trim()
+import { execSync } from 'child_process'
+import { createHash } from 'crypto'
+import {
+  readFileSync, writeFileSync, unlinkSync, mkdirSync, existsSync,
+  appendFileSync, readdirSync, statSync, copyFileSync,
+} from 'fs'
+import { homedir } from 'os'
+import { join, resolve as resolvePath, sep as pathSep, basename, dirname } from 'path'
+import {
+  RuntimeApiClient,
+  MessageQueue,
+  SseEventHandler,
+  ThreadMap,
+  injectFeishuMcpConfig,
+  buildSystemPrompt,
+} from './runtime-api'
+import type { QueuedMessage, SseDelta, TurnInfo } from './runtime-api'
+import { startEmailWorker, stopEmailWorker } from './email-worker'
+import { startStatusDashboard } from './status-dashboard'
+
+// ── State paths ──────────────────────────────────────────────────────────────
+
+const STATE_DIR = join(homedir(), '.deepseek', 'lodestar')
+const PID_FILE = join(STATE_DIR, 'daemon.pid')
+const LOG_FILE = join(STATE_DIR, 'daemon.log')
+const INBOX_DIR = join(STATE_DIR, 'inbox')
+const PROJECTS_ROOT = process.env.FEISHU_PROJECTS_ROOT ?? homedir()
+
+// Runtime API config
+const API_URL = process.env.DEEPSEEK_API_URL ?? 'http://localhost:7878'
+const API_TOKEN = process.env.DEEPSEEK_API_TOKEN ?? ''
+
+function sanitizeSessionName(raw: string): string {
+  return raw.replace(/[^\w一-鿿\-]/g, '_').slice(0, 64)
+}
+
+const APP_ID = process.env.FEISHU_APP_ID
+const APP_SECRET = process.env.FEISHU_APP_SECRET
+
+if (!APP_ID || !APP_SECRET) {
+  console.error('feishu-daemon: FEISHU_APP_ID and FEISHU_APP_SECRET required')
+  console.error('  run: lodestar configure')
+  console.error('  or edit: ~/.deepseek/lodestar.toml')
+  process.exit(1)
+}
+
+// ── Lark client ──────────────────────────────────────────────────────────────
+
+const client = new lark.Client({
+  appId: APP_ID,
+  appSecret: APP_SECRET,
+  disableTokenCache: false,
+})
+
+// ── Runtime API client ───────────────────────────────────────────────────────
+
+const api = new RuntimeApiClient({ baseUrl: API_URL, authToken: API_TOKEN })
+const msgQueue = new MessageQueue()
+const threadMap = new ThreadMap()
+
+// ── Group name cache: chat_id → name ─────────────────────────────────────────
+
+const chatNameCache = new Map<string, string>()
+
+// Session name → preferred chat_id (same as original — handles duplicate group names)
+const SESSION_CHAT_MAP_FILE = join(STATE_DIR, 'session-chat-map.json')
+const preferredChatForSession = new Map<string, string>()
+
+function loadSessionChatMap(): void {
   try {
-    process.kill(Number(existing), 0)
-    console.error(`lodestar-daemon: already running (pid ${existing})`)
-    process.exit(1)
+    const raw = readFileSync(SESSION_CHAT_MAP_FILE, 'utf-8')
+    const obj = JSON.parse(raw)
+    for (const [name, id] of Object.entries(obj)) {
+      if (typeof id === 'string') preferredChatForSession.set(name, id)
+    }
+    log(`loaded session→chat map: ${preferredChatForSession.size} bindings`)
   } catch {}
-} catch {}
+}
+
+function saveSessionChatMap(): void {
+  try {
+    const obj: Record<string, string> = {}
+    for (const [name, id] of preferredChatForSession.entries()) obj[name] = id
+    writeFileSync(SESSION_CHAT_MAP_FILE, JSON.stringify(obj, null, 2))
+  } catch (err) {
+    log(`save session→chat map failed: ${err}`)
+  }
+}
+
+function bindSessionToChat(sessionName: string, chatId: string): void {
+  if (preferredChatForSession.get(sessionName) === chatId) return
+  const prev = preferredChatForSession.get(sessionName)
+  preferredChatForSession.set(sessionName, chatId)
+  saveSessionChatMap()
+  log(`bound session "${sessionName}" → chat ${chatId}${prev ? ` (was ${prev})` : ''}`)
+}
+
+async function refreshChatList(): Promise<void> {
+  try {
+    let pageToken: string | undefined
+    do {
+      const res = await client.im.chat.list({
+        params: { page_size: 100, ...(pageToken ? { page_token: pageToken } : {}) },
+      })
+      for (const chat of res.data?.items ?? []) {
+        if (chat.chat_id && chat.name) {
+          chatNameCache.set(chat.chat_id, chat.name)
+        }
+      }
+      pageToken = res.data?.page_token
+    } while (pageToken)
+    log(`refreshed chat list: ${chatNameCache.size} groups`)
+  } catch (err) {
+    log(`refresh chat list failed: ${err}`)
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function log(msg: string): void {
+  const line = `[${new Date().toISOString()}] ${msg}`
+  try {
+    mkdirSync(STATE_DIR, { recursive: true })
+    appendFileSync(LOG_FILE, line + '\n')
+  } catch {}
+}
+
+// ── Feishu send helpers ─────────────────────────────────────────────────────
+
+async function getToken(): Promise<string> {
+  const res = await fetch('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ app_id: APP_ID, app_secret: APP_SECRET }),
+  })
+  const data = await res.json() as any
+  return data.tenant_access_token
+}
+
+async function addReaction(messageId: string, emojiType: string): Promise<string | undefined> {
+  if (!messageId) return
+  try {
+    const res: any = await client.im.messageReaction.create({
+      path: { message_id: messageId },
+      data: { reaction_type: { emoji_type: emojiType } },
+    })
+    return res?.data?.reaction_id
+  } catch (err) {
+    log(`react ${emojiType} failed on ${messageId}: ${err}`)
+  }
+}
+
+async function sendTextMessage(chatId: string, text: string): Promise<string | null> {
+  try {
+    const res: any = await client.im.message.create({
+      params: { receive_id_type: 'chat_id' },
+      data: {
+        receive_id: chatId,
+        msg_type: 'text',
+        content: JSON.stringify({ text }),
+      },
+    })
+    if (res && typeof res.code === 'number' && res.code !== 0) {
+      log(`send message rejected by Lark: chat=${chatId} code=${res.code} msg=${res.msg}`)
+      return null
+    }
+    return res?.data?.message_id ?? null
+  } catch (e) {
+    log(`send message failed: chat=${chatId} err=${e}`)
+    return null
+  }
+}
+
+async function sendCardMessage(chatId: string, card: object): Promise<boolean> {
+  try {
+    const res: any = await client.im.message.create({
+      params: { receive_id_type: 'chat_id' },
+      data: {
+        receive_id: chatId,
+        msg_type: 'interactive',
+        content: JSON.stringify(card),
+      },
+    })
+    if (res && typeof res.code === 'number' && res.code !== 0) {
+      log(`send card rejected by Lark: chat=${chatId} code=${res.code} msg=${res.msg}`)
+      return false
+    }
+    return true
+  } catch (e) {
+    log(`send card failed: chat=${chatId} err=${e}`)
+    return false
+  }
+}
+
+// ── Image/file download ─────────────────────────────────────────────────────
+
+async function downloadAttachment(
+  messageId: string,
+  key: string,
+  type: 'image' | 'file',
+  name?: string,
+): Promise<string | undefined> {
+  try {
+    const token = await getToken()
+    const url = `https://open.feishu.cn/open-apis/im/v1/messages/${messageId}/resources/${key}?type=${type}`
+    log(`downloading ${type}: ${url}`)
+    const res = await fetch(url, {
+      headers: { 'Authorization': `Bearer ${token}` },
+    })
+    if (!res.ok) {
+      const body = await res.text()
+      log(`${type} download HTTP ${res.status}: ${body.slice(0, 200)}`)
+      return undefined
+    }
+    const buf = Buffer.from(await res.arrayBuffer())
+    mkdirSync(INBOX_DIR, { recursive: true })
+    const safeName = name
+      ? name.replace(/[^a-zA-Z0-9._-]/g, '_')
+      : `${key.replace(/[^a-zA-Z0-9_-]/g, '_')}.png`
+    const path = join(INBOX_DIR, `${Date.now()}-${safeName}`)
+    writeFileSync(path, buf)
+    log(`downloaded ${type} to ${path} (${buf.length} bytes)`)
+    return path
+  } catch (err) {
+    log(`${type} download failed: ${err instanceof Error ? err.message : String(err)}`)
+  }
+  return undefined
+}
+
+// ── Slash alias expansion ───────────────────────────────────────────────────
+
+const SLASH_ALIASES: Record<string, string> = {
+  ap: '/oh-my-claudecode:autopilot',
+  ulw: '/oh-my-claudecode:ultrawork',
+  cl: '/oh-my-claudecode:cancel',
+}
+
+function expandSlashAlias(text: string): string {
+  if (!text) return text
+  const tokens = text.split(/\s+/).filter(Boolean)
+  if (tokens.length === 0) return text
+
+  const lookup = (tok: string): string | null => {
+    if (!tok.startsWith('/')) return null
+    return SLASH_ALIASES[tok.slice(1).toLowerCase()] ?? null
+  }
+
+  const firstHit = lookup(tokens[0])
+  if (firstHit) return [firstHit, ...tokens.slice(1)].join(' ').trim()
+
+  if (tokens.length > 1) {
+    const lastHit = lookup(tokens[tokens.length - 1])
+    if (lastHit) return [lastHit, ...tokens.slice(0, -1)].join(' ').trim()
+  }
+
+  return text
+}
+
+// ── Project tree (ls command) ────────────────────────────────────────────────
+
+const TREE_IGNORE = new Set([
+  '.git', '.claude', '.omc',
+  'node_modules', '__pycache__', '.venv', 'venv',
+  'dist', 'build', 'target', '.next', '.turbo', '.cache',
+  '.bun', '.pytest_cache', '.mypy_cache', '.ruff_cache',
+])
+
+const TREE_MAX_LINES = 100
+const TREE_FOLDER_THRESHOLD = 12
+
+function renderProjectTreeBody(rootDir: string): string {
+  const lines: string[] = []
+  let truncated = false
+
+  function walk(dir: string, prefix: string): void {
+    if (lines.length >= TREE_MAX_LINES) { truncated = true; return }
+    let entries: { name: string; isDir: boolean }[]
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+        .filter(e => !TREE_IGNORE.has(e.name))
+        .map(e => ({ name: e.name, isDir: e.isDirectory() }))
+        .sort((a, b) => {
+          if (a.isDir !== b.isDir) return a.isDir ? -1 : 1
+          return a.name.localeCompare(b.name)
+        })
+    } catch { return }
+
+    let visible = entries
+    let collapsedCount = 0
+    if (entries.length > TREE_FOLDER_THRESHOLD) {
+      visible = entries.slice(0, TREE_FOLDER_THRESHOLD)
+      collapsedCount = entries.length - TREE_FOLDER_THRESHOLD
+    }
+
+    for (let i = 0; i < visible.length; i++) {
+      if (lines.length >= TREE_MAX_LINES) { truncated = true; return }
+      const e = visible[i]
+      const isLastVisible = i === visible.length - 1 && collapsedCount === 0
+      const branch = isLastVisible ? '└── ' : '├── '
+      lines.push(prefix + branch + e.name + (e.isDir ? '/' : ''))
+      if (e.isDir) {
+        walk(join(dir, e.name), prefix + (isLastVisible ? '    ' : '│   '))
+        if (lines.length >= TREE_MAX_LINES) { truncated = true; return }
+      }
+    }
+    if (collapsedCount > 0) {
+      if (lines.length >= TREE_MAX_LINES) { truncated = true; return }
+      lines.push(prefix + `└── … more ${collapsedCount} 个`)
+    }
+  }
+
+  walk(rootDir, '')
+
+  if (truncated) {
+    if (lines.length >= TREE_MAX_LINES) lines.length = TREE_MAX_LINES - 1
+    lines.push('… (已截断到 100 行)')
+  }
+  return lines.join('\n')
+}
+
+// ── Provision new project ───────────────────────────────────────────────────
+
+function provisionProject(workDir: string): void {
+  mkdirSync(workDir, { recursive: true })
+  log(`provisioned directory ${workDir}`)
+
+  // Run git init so the new project has version control from the start
+  try {
+    execSync('git init', { cwd: workDir, timeout: 10_000 })
+    log(`git init in ${workDir}`)
+  } catch (err) {
+    log(`git init in ${workDir} failed: ${err}`)
+  }
+}
+
+// ── Resolve chat_id for a session name ──────────────────────────────────────
+
+function chatIdForSession(sessionName: string): string | null {
+  const preferred = preferredChatForSession.get(sessionName)
+  if (preferred && chatNameCache.get(preferred) === sessionName) return preferred
+
+  const matches: string[] = []
+  for (const [id, name] of chatNameCache.entries()) {
+    if (name === sessionName) matches.push(id)
+  }
+  if (matches.length === 1) return matches[0]
+  if (matches.length > 1) {
+    log(`chatIdForSession("${sessionName}"): ${matches.length} chats share this name and no binding — [${matches.join(', ')}]`)
+    return null
+  }
+  return null
+}
+
+// ── SSE event handling (stream output to Feishu) ────────────────────────────
+
+// Accumulates agent_message text and sends single complete reply on turn.completed.
+// Feishu PATCH endpoint doesn't support text message updates, so we accumulate
+// all deltas and send once. During processing, a 👌 reaction on the user's
+// message indicates the bot is working.
+const streamBuffers = new Map<string, {
+  text: string
+  chatId: string
+  userMessageId?: string   // original feishu message to react to
+  reasoningText: string
+}>()
+
+const sseHandler = new SseEventHandler(api)
+
+sseHandler.onDelta = (threadId: string, delta: SseDelta) => {
+  if (delta.kind === 'agent_reasoning') {
+    const buf = streamBuffers.get(threadId)
+    if (buf) buf.reasoningText += delta.delta
+    return
+  }
+
+  if (delta.kind === 'agent_message') {
+    const buf = streamBuffers.get(threadId)
+    if (buf) buf.text += delta.delta
+    return
+  }
+}
+
+sseHandler.onTurnCompleted = (threadId: string, _turn: TurnInfo) => {
+  const buf = streamBuffers.get(threadId)
+  if (!buf) return
+
+  const text = buf.text.trim()
+  buf.text = ''
+  buf.reasoningText = ''
+
+  if (text) {
+    // Send complete reply — use card format if markdown detected
+    sendCardIfMarkdown(buf.chatId, text)
+  }
+
+  // Clear active turn
+  msgQueue.clearActiveTurn(threadId)
+
+  // Inject next queued message if any
+  const next = msgQueue.dequeue(threadId)
+  if (next) {
+    injectMessage(threadId, next)
+  }
+}
+
+function initStreamBuffer(threadId: string, chatId: string, userMessageId?: string): void {
+  streamBuffers.set(threadId, {
+    text: '',
+    chatId,
+    userMessageId,
+    reasoningText: '',
+  })
+}
+
+/** Send as interactive card if text has markdown, else plain text. */
+async function sendCardIfMarkdown(chatId: string, text: string): Promise<void> {
+  // Simple markdown detection — if present, send as card for better mobile rendering
+  const hasMd = /(?:^#{1,6}\s|^[-*]\s|```|\*\*|`[^`]+`)/m.test(text)
+  if (hasMd) {
+    try {
+      const card = markdownToCard(text)
+      await sendCardMessageRaw(chatId, card)
+      return
+    } catch (err) {
+      log(`send card failed, falling back to text: ${err}`)
+    }
+  }
+  await sendTextMessage(chatId, text)
+}
+
+/** Simple markdown → Feishu card (v2 schema). */
+function markdownToCard(text: string): string {
+  const MAX_LEN = 28000
+  const parts: string[] = []
+  let rest = text
+  while (rest.length > MAX_LEN) {
+    const cut = rest.lastIndexOf('\n\n', MAX_LEN)
+    parts.push(rest.slice(0, cut > MAX_LEN / 2 ? cut : MAX_LEN))
+    rest = rest.slice(cut > MAX_LEN / 2 ? cut : MAX_LEN)
+  }
+  if (rest) parts.push(rest)
+  const elements = parts.map(p => ({ tag: 'markdown', content: p }))
+  return JSON.stringify({ schema: '2.0', config: { wide_screen_mode: true }, body: { elements } })
+}
+
+/** Send a raw card JSON to feishu. */
+async function sendCardMessageRaw(chatId: string, cardJson: string): Promise<void> {
+  try {
+    const res: any = await client.im.message.create({
+      params: { receive_id_type: 'chat_id' },
+      data: { receive_id: chatId, msg_type: 'interactive', content: cardJson },
+    })
+    if (res && typeof res.code === 'number' && res.code !== 0) {
+      log(`send card rejected: chat=${chatId} code=${res.code} msg=${res.msg}`)
+    }
+  } catch (e) {
+    log(`send card failed: chat=${chatId} err=${e}`)
+  }
+}
+
+// ── Message injection ───────────────────────────────────────────────────────
+
+async function injectMessage(threadId: string, msg: QueuedMessage): Promise<void> {
+  const sessionName = threadMap.getSessionName(threadId)
+  if (!sessionName) {
+    log(`injectMessage: no session name for thread ${threadId}`)
+    return
+  }
+
+  // Initialize stream buffer for this thread's chat
+  const chatId = msg.chatId
+  initStreamBuffer(threadId, chatId)
+
+  let prompt = `[飞书] ${msg.sender} (${msg.messageId}): ${msg.text}`
+  if (msg.filePath) {
+    prompt += `\n\n附件已下载到: ${msg.filePath}`
+  }
+
+  // Build the full prompt with file context
+  // For images, tell the model to read the file
+  if (msg.filePath && /\.(png|jpe?g|gif|webp|bmp)$/i.test(msg.filePath)) {
+    prompt += `\n\n（这是一张图片，请使用 read 工具查看: ${msg.filePath}）`
+  }
+
+  try {
+    if (msgQueue.hasActiveTurn(threadId)) {
+      // Interrupt current turn and inject new message
+      const activeTurnId = msgQueue.getActiveTurnId(threadId)
+      if (activeTurnId) {
+        await api.interruptTurn(threadId, activeTurnId).catch(err =>
+          log(`interrupt failed for ${threadId}/${activeTurnId}: ${err}`))
+      }
+    }
+
+    const turnRes = await api.createTurn(threadId, {
+      prompt,
+      auto_approve: true,
+      mode: 'yolo',
+    })
+
+    msgQueue.setActiveTurn(threadId, turnRes.turn.id)
+    log(`injected turn ${turnRes.turn.id} for thread "${sessionName}" (${threadId})`)
+  } catch (err) {
+    log(`injectMessage failed for thread ${threadId}: ${err}`)
+    msgQueue.clearActiveTurn(threadId)
+  }
+}
+
+// ── Control command handlers ────────────────────────────────────────────────
+
+async function handleHi(sessionName: string, chatId: string, workDir: string): Promise<void> {
+  // Check if we already have a thread for this session
+  let threadId = threadMap.getThreadId(sessionName)
+
+  if (threadId) {
+    // Thread exists — show status
+    const threadInfo = await api.getThreadInfo(threadId)
+    if (threadInfo) {
+      const lines = [
+        `🟢 DeepSeek 已在运行`,
+        `session: ${sessionName}`,
+        `thread: ${threadInfo.id}`,
+        `workspace: ${threadInfo.workspace}`,
+        `status: ${threadInfo.archived ? '已归档 (发送 hi 创建新会话)' : '活跃'}`,
+      ]
+      if (threadInfo.archived) {
+        lines.push('')
+        lines.push('该会话已归档。发送 "hi" 将创建新的会话。')
+        // Clear the mapping for archived threads so next hi creates a new one
+        threadMap.removeThreadId(sessionName)
+        threadId = undefined
+      }
+      await sendTextMessage(chatId, lines.join('\n'))
+    } else {
+      // Thread may have been deleted — clear mapping
+      threadMap.removeThreadId(sessionName)
+      threadId = undefined
+    }
+    if (threadId) return
+  }
+
+  // No thread — create a new one
+  const isNewProject = !existsSync(workDir)
+  if (isNewProject) {
+    await sendTextMessage(chatId, `🆕 目录 ~/${sessionName} 不存在，正在创建新项目...`)
+    try {
+      provisionProject(workDir)
+    } catch (e) {
+      await sendTextMessage(chatId, `❌ 创建项目失败: ${e}`)
+      log(`provisionProject failed for ${workDir}: ${e}`)
+      return
+    }
+  }
+
+  const groupName = chatNameCache.get(chatId) ?? sessionName
+  const systemPrompt = buildSystemPrompt(groupName, chatId, workDir)
+
+  try {
+    const thread = await api.createThread({
+      title: sessionName,
+      workspace: workDir,
+      mode: 'yolo',
+      auto_approve: true,
+      system_prompt: systemPrompt,
+      model: '', // use default from config.toml
+    })
+
+    threadMap.setThreadId(sessionName, thread.id)
+    log(`created thread ${thread.id} for session "${sessionName}"`)
+
+    // Initialize SSE stream buffer so model output flows to feishu
+    initStreamBuffer(thread.id, chatId)
+
+    // Start SSE stream for this thread
+    sseHandler.connect(thread.id).catch(err =>
+      log(`SSE connect failed for ${thread.id}: ${err}`))
+
+    const sent = await sendTextMessage(chatId, [
+      `✅ DeepSeek 已就绪，可以开始对话`,
+      `session: ${sessionName}`,
+      `workspace: ${workDir}`,
+      isNewProject ? `已初始化 git 仓库` : '',
+      '',
+      `指令: hi 状态 | restart 重启 | kill 关闭 | clear 清上下文`,
+    ].filter(Boolean).join('\n'))
+    log(`sent greeting to ${chatId}: ${sent ? 'OK' : 'FAIL'}`)
+  } catch (err) {
+    log(`createThread failed for "${sessionName}": ${err}`)
+    await sendTextMessage(chatId, `❌ 启动失败: ${err}`)
+  }
+}
+
+async function handleKill(sessionName: string, chatId: string): Promise<void> {
+  const threadId = threadMap.getThreadId(sessionName)
+  if (!threadId) {
+    await sendTextMessage(chatId, `⚠️ 没有运行中的会话: ${sessionName}`)
+    return
+  }
+
+  try {
+    await api.archiveThread(threadId)
+    threadMap.removeThreadId(sessionName)
+    sseHandler.disconnect(threadId)
+    msgQueue.clearThread(threadId)
+    streamBuffers.delete(threadId)
+    await sendTextMessage(chatId, `🔴 会话已关闭 (session: ${sessionName})`)
+    log(`archived thread ${threadId} for session "${sessionName}"`)
+  } catch (err) {
+    log(`archiveThread failed for ${threadId}: ${err}`)
+    await sendTextMessage(chatId, `⚠️ 关闭失败: ${err}`)
+  }
+}
+
+async function handleRestart(sessionName: string, chatId: string, workDir: string): Promise<void> {
+  const threadId = threadMap.getThreadId(sessionName)
+  if (!threadId) {
+    // No thread — treat like hi (fresh start)
+    await handleHi(sessionName, chatId, workDir)
+    return
+  }
+
+  try {
+    // Interrupt any active turn first
+    const activeTurnId = msgQueue.getActiveTurnId(threadId)
+    if (activeTurnId) {
+      await api.interruptTurn(threadId, activeTurnId).catch(() => {})
+      msgQueue.clearActiveTurn(threadId)
+    }
+
+    // Fork: creates a new thread preserving the session context
+    const newThread = await api.forkThread(threadId)
+
+    // Archive the old thread
+    await api.archiveThread(threadId).catch(err =>
+      log(`archive old thread failed: ${err}`))
+
+    // Clean up old
+    sseHandler.disconnect(threadId)
+    msgQueue.clearThread(threadId)
+    streamBuffers.delete(threadId)
+
+    // Set up new
+    threadMap.setThreadId(sessionName, newThread.id)
+    initStreamBuffer(newThread.id, chatId)
+    sseHandler.connect(newThread.id).catch(err =>
+      log(`SSE connect failed for ${newThread.id}: ${err}`))
+
+    await sendTextMessage(chatId, `✅ 会话已重启 (session: ${sessionName})`)
+    log(`restarted session "${sessionName}": ${threadId} → ${newThread.id}`)
+  } catch (err) {
+    log(`handleRestart failed for "${sessionName}": ${err}`)
+    await sendTextMessage(chatId, `❌ 重启失败: ${err}`)
+  }
+}
+
+async function handleClear(sessionName: string, chatId: string, workDir: string): Promise<void> {
+  const oldThreadId = threadMap.getThreadId(sessionName)
+  if (!oldThreadId) {
+    await sendTextMessage(chatId, `⚠️ 没有运行中的会话: ${sessionName}`)
+    return
+  }
+
+  try {
+    // Archive old thread
+    await api.archiveThread(oldThreadId).catch(err => log(`archive old thread failed: ${err}`))
+    sseHandler.disconnect(oldThreadId)
+    msgQueue.clearThread(oldThreadId)
+    streamBuffers.delete(oldThreadId)
 
-mkdirSync(dirname(PID_FILE), { recursive: true })
-writeFileSync(PID_FILE, String(process.pid))
+    // Create fresh thread with same workspace + system_prompt
+    const groupName = chatNameCache.get(chatId) ?? sessionName
+    const systemPrompt = buildSystemPrompt(groupName, chatId, workDir)
 
-const cleanup = () => { try { unlinkSync(PID_FILE) } catch {} }
-process.on('exit', cleanup)
-process.on('SIGTERM', () => { log('SIGTERM'); cleanup(); process.exit(0) })
-process.on('SIGINT',  () => { log('SIGINT');  cleanup(); process.exit(0) })
-process.on('unhandledRejection', e => log(`unhandledRejection: ${e}`))
-process.on('uncaughtException',  e => log(`uncaughtException: ${e}`))
+    const newThread = await api.createThread({
+      title: sessionName,
+      workspace: workDir,
+      mode: 'yolo',
+      auto_approve: true,
+      system_prompt: systemPrompt,
+      model: '',
+    })
 
-// ── Session registry ────────────────────────────────────────────────────
-const sessions = new Map<string, Session>()  // key = chatId
+    threadMap.setThreadId(sessionName, newThread.id)
+    initStreamBuffer(newThread.id, chatId)
+    sseHandler.connect(newThread.id).catch(err =>
+      log(`SSE connect failed for ${newThread.id}: ${err}`))
 
-function sessionFor(chatId: string, sessionName: string): Session {
-  let s = sessions.get(chatId)
-  if (!s) {
-    s = new Session(sessionName, chatId)
-    sessions.set(chatId, s)
+    await sendTextMessage(chatId, `🧹 上下文已清空，全新会话开始 (session: ${sessionName})`)
+    log(`cleared session "${sessionName}": ${oldThreadId} → ${newThread.id}`)
+  } catch (err) {
+    log(`handleClear failed for "${sessionName}": ${err}`)
+    await sendTextMessage(chatId, `⚠️ 清理失败: ${err}`)
   }
-  return s
 }
 
-// ── Inbound message handler ─────────────────────────────────────────────
+// ── Card action handler (permission approve/deny) ───────────────────────────
+
+const processedActions = new Set<string>()
+
+async function handleCardAction(data: any): Promise<any> {
+  const action = data?.action
+  const value = action?.value
+  if (!value?.action || !value?.request_id) return
+
+  const requestId = value.request_id as string
+  const behavior = value.action as string // 'allow' or 'deny'
+
+  const dedup = `${requestId}:${behavior}`
+  if (processedActions.has(dedup)) return
+  processedActions.add(dedup)
+  if (processedActions.size > 100) {
+    const arr = [...processedActions]
+    for (let i = 0; i < 50; i++) processedActions.delete(arr[i])
+  }
+
+  log(`card action: ${behavior} ${requestId}`)
+
+  try {
+    if (behavior === 'allow' || behavior === 'deny') {
+      await api.handleApproval(requestId, behavior)
+    }
+  } catch (err) {
+    log(`handleApproval failed for ${requestId}: ${err}`)
+  }
+
+  // Build a response card (simplified — toast confirmation)
+  const resultText = behavior === 'allow' ? '✅ 已批准' : '❌ 已拒绝'
+  return {
+    toast: {
+      type: behavior === 'allow' ? 'success' : 'error',
+      content: resultText,
+    },
+  }
+}
+
+// ── Event handler ────────────────────────────────────────────────────────────
+
+const processedMessages = new Set<string>()
 const STALE_THRESHOLD_MS = 10_000
-const seenMessageIds = new Set<string>()
 
 async function handleMessage(data: any): Promise<void> {
   const message = data?.message
   if (!message) return
 
-  const msgId = message.message_id as string | undefined
-  if (msgId && seenMessageIds.has(msgId)) return
+  const msgId = message.message_id
+  if (msgId && processedMessages.has(msgId)) return
   if (msgId) {
-    seenMessageIds.add(msgId)
-    if (seenMessageIds.size > 200) {
-      const arr = [...seenMessageIds]
-      seenMessageIds.clear()
-      for (const id of arr.slice(-100)) seenMessageIds.add(id)
+    processedMessages.add(msgId)
+    if (processedMessages.size > 100) {
+      const arr = [...processedMessages]
+      for (let i = 0; i < 50; i++) processedMessages.delete(arr[i])
     }
   }
 
-  // Drop replays of stale messages (Lark redelivers unacked events on reconnect).
-  const createTime = Number(message.create_time ?? 0)
-  if (createTime > 0 && Date.now() - createTime > STALE_THRESHOLD_MS) {
-    log(`drop stale message ${msgId} age=${Math.round((Date.now() - createTime) / 1000)}s`)
-    if (msgId) void feishu.addReaction(msgId, 'CrossMark')
+  const chatId = message.chat_id
+  const msgType = message.message_type
+
+  // Drop stale messages
+  const createTimeMs = Number(message.create_time ?? 0)
+  if (createTimeMs > 0) {
+    const ageMs = Date.now() - createTimeMs
+    if (ageMs > STALE_THRESHOLD_MS) {
+      const ageSec = Math.round(ageMs / 1000)
+      let preview = `(${msgType})`
+      try {
+        const obj = JSON.parse(message.content ?? '{}')
+        const raw = (msgType === 'text' ? obj.text ?? '' : '').trim()
+        if (raw) preview = raw.length > 10 ? raw.slice(0, 10) + '…' : raw
+      } catch {}
+      log(`dropping stale message ${msgId} from ${chatId}, age=${ageSec}s, preview="${preview}"`)
+      void addReaction(msgId, 'CrossMark')
+      return
+    }
+  }
+
+  // Immediate seen signal
+  void addReaction(msgId, 'OK')
+
+  let contentObj: any = {}
+  try { contentObj = JSON.parse(message.content ?? '{}') } catch {}
+  const text = (msgType === 'text' ? contentObj.text ?? '' : '').trim()
+  const cmd = text.toLowerCase()
+
+  const isOpt = /^opt[1-5]$/.test(cmd)
+  const lsMatch = cmd.match(/^ls(?:\s+(.+))?$/)
+  const isLs = !!lsMatch
+  const isControl = cmd === 'hi' || cmd === 'restart' || cmd === 'kill' || cmd === 'clear' || isOpt || isLs
+
+  // Non-control messages: inject as turn
+  if (!isControl) {
+    const groupName = chatNameCache.get(chatId)
+    if (groupName) bindSessionToChat(groupName, chatId)
+
+    const sessionName = groupName ? sanitizeSessionName(groupName) : null
+    const threadId = sessionName ? threadMap.getThreadId(sessionName) : undefined
+
+    if (!threadId || !sessionName) {
+      log(`no thread for message from chat ${chatId} (group: ${groupName ?? 'unknown'})`)
+      return
+    }
+
+    // Download attachments
+    let filePath: string | undefined
+    if (msgType === 'image' && contentObj.image_key) {
+      filePath = await downloadAttachment(message.message_id, contentObj.image_key, 'image')
+    } else if (msgType === 'file' && contentObj.file_key) {
+      filePath = await downloadAttachment(message.message_id, contentObj.file_key, 'file', contentObj.file_name)
+    }
+
+    const expandedText = expandSlashAlias(text)
+    if (expandedText !== text) log(`expanded slash alias: "${text}" → "${expandedText}"`)
+
+    const msg: QueuedMessage = {
+      chatId,
+      messageId: message.message_id,
+      sender: data.sender?.sender_id?.open_id ?? 'unknown',
+      text: expandedText || `(${msgType})`,
+      filePath,
+      timestamp: Date.now(),
+    }
+
+    // Inject immediately if no active turn, otherwise interrupt + inject
+    injectMessage(threadId, msg)
+
+    // Stamp last user message time for dashboard
+    try { writeFileSync(join(STATE_DIR, 'last_user_message'), String(Math.floor(Date.now() / 1000))) } catch {}
     return
   }
-  if (msgId) void feishu.addReaction(msgId, 'OK')
 
-  const chatId = message.chat_id as string
-  let groupName = feishu.chatNameCache.get(chatId)
+  // Control commands below: only text messages
+  if (msgType !== 'text') return
+
+  // Resolve group name
+  let groupName = chatNameCache.get(chatId)
   if (!groupName) {
-    await feishu.refreshChatList()
-    groupName = feishu.chatNameCache.get(chatId)
+    await refreshChatList()
+    groupName = chatNameCache.get(chatId)
   }
   if (!groupName) {
-    log(`unknown chat ${chatId}, dropping message`)
-    await feishu.sendText(chatId, '❌ 无法识别群名，请确认机器人已加入并稍后重试')
+    await new Promise(r => setTimeout(r, 2000))
+    await refreshChatList()
+    groupName = chatNameCache.get(chatId)
+  }
+  if (!groupName) {
+    try {
+      const res = await client.im.chat.get({ path: { chat_id: chatId } })
+      groupName = res.data?.name ?? undefined
+      if (groupName) chatNameCache.set(chatId, groupName)
+    } catch {}
+  }
+  if (!groupName) {
+    log(`received "${cmd}" from unknown group ${chatId}, cannot resolve name`)
+    await sendTextMessage(chatId, '❌ 无法识别群名，请确认机器人已加入群聊')
     return
   }
-  const sessionName = feishu.sanitizeSessionName(groupName)
-  feishu.bindSessionToChat(sessionName, chatId)
-  const session = sessionFor(chatId, sessionName)
 
-  let contentObj: any = {}
-  try { contentObj = JSON.parse(message.content ?? '{}') } catch {}
-  const msgType = message.message_type as string
-  let text = (msgType === 'text' ? contentObj.text ?? '' : '').trim()
+  const sessionName = sanitizeSessionName(groupName)
+  const workDir = join(PROJECTS_ROOT, sessionName)
+
+  bindSessionToChat(sessionName, chatId)
+  log(`received "${cmd}" in group "${groupName}" (${chatId})`)
 
-  // Text-only control commands — intercept before any work that would
-  // forward to Claude (download / spawn / interrupt). Exact match,
-  // case-insensitive: `hi` `kill` `restart` `clear`. Bare words are
-  // reserved globally by user request — typing "hi" as a literal
-  // greeting will trigger the dashboard, not reach Claude.
-  if (msgType === 'text' && text) {
-    if (await session.runCommand(text)) return
+  if (cmd === 'hi') {
+    await handleHi(sessionName, chatId, workDir)
+  } else if (cmd === 'kill') {
+    await handleKill(sessionName, chatId)
+  } else if (cmd === 'restart') {
+    await handleRestart(sessionName, chatId, workDir)
+  } else if (cmd === 'clear') {
+    await handleClear(sessionName, chatId, workDir)
+  } else if (isOpt) {
+    // opt1~5 — steer to active turn
+    const threadId = threadMap.getThreadId(sessionName)
+    if (!threadId || !msgQueue.hasActiveTurn(threadId)) {
+      await sendTextMessage(chatId, `⚠️ 没有活跃的会话可以追加选项`)
+      return
+    }
+    const turnId = msgQueue.getActiveTurnId(threadId)!
+    try {
+      await api.steerTurn(threadId, turnId, text)
+      await sendTextMessage(chatId, `✅ 已追加选项: ${text}`)
+    } catch (err) {
+      log(`steerTurn failed: ${err}`)
+    }
+  } else if (isLs) {
+    const subPath = lsMatch?.[1] ?? ''
+    const target = subPath ? join(workDir, subPath) : workDir
+    if (!existsSync(target)) {
+      await sendTextMessage(chatId, `❌ 路径不存在: ${subPath || '~/' + sessionName}`)
+      return
+    }
+    const tree = renderProjectTreeBody(target)
+    const header = subPath
+      ? `📁 ~/${sessionName}/${subPath}`
+      : `📁 ~/${sessionName}`
+    await sendTextMessage(chatId, `${header}\n\`\`\`\n${tree}\n\`\`\``)
   }
+}
+
+// ── PID management ───────────────────────────────────────────────────────────
+
+function writePid(): void {
+  mkdirSync(STATE_DIR, { recursive: true })
+  writeFileSync(PID_FILE, String(process.pid))
+}
+
+function cleanPid(): void {
+  try { unlinkSync(PID_FILE) } catch {}
+}
 
-  let filePath: string | undefined
-  if (msgType === 'image' && contentObj.image_key) {
-    filePath = await feishu.downloadAttachment(message.message_id, contentObj.image_key, 'image')
-  } else if (msgType === 'file' && contentObj.file_key) {
-    filePath = await feishu.downloadAttachment(message.message_id, contentObj.file_key, 'file', contentObj.file_name)
-    if (!text) text = `(file: ${contentObj.file_name})`
+try {
+  const existingPid = readFileSync(PID_FILE, 'utf8').trim()
+  try {
+    process.kill(Number(existingPid), 0)
+    console.error(`feishu-daemon: already running (pid ${existingPid}). Use "kill ${existingPid}" to stop it first.`)
+    process.exit(1)
+  } catch {}
+} catch {}
+
+// ── Boot ─────────────────────────────────────────────────────────────────────
+
+process.on('unhandledRejection', err => log(`unhandled rejection: ${err}`))
+process.on('uncaughtException', err => log(`uncaught exception: ${err}`))
+
+process.on('SIGTERM', () => {
+  log('received SIGTERM, shutting down')
+  sseHandler.disconnectAll()
+  stopEmailWorker()
+  cleanPid()
+  process.exit(0)
+})
+
+process.on('SIGINT', () => {
+  log('received SIGINT, shutting down')
+  sseHandler.disconnectAll()
+  stopEmailWorker()
+  cleanPid()
+  process.exit(0)
+})
+
+function ensureStateDir(): void {
+  mkdirSync(STATE_DIR, { recursive: true })
+  mkdirSync(INBOX_DIR, { recursive: true })
+  mkdirSync(join(STATE_DIR, 'messages'), { recursive: true }) // for backward compat
+
+  // Install feishu-mcp.ts to state dir if not present
+  const mcpDest = join(STATE_DIR, 'feishu-mcp.ts')
+  const mcpSrc = join(dirname(new URL(import.meta.url).pathname), 'feishu-mcp.ts')
+  if (!existsSync(mcpDest) && existsSync(mcpSrc)) {
+    try {
+      copyFileSync(mcpSrc, mcpDest)
+      log('installed feishu-mcp.ts to state dir')
+    } catch (err) {
+      log(`install feishu-mcp.ts failed: ${err}`)
+    }
   }
+}
+
+// ── WS reconnect with exponential backoff ───────────────────────────────────
 
-  if (!text && !filePath) return
-  await session.onUserMessage(text || '(empty)', filePath ? [filePath] : [])
+// Module-level pong tracker (shared across WS reconnects, single watchdog timer)
+let lastPongAt = Date.now()
+let watchdogTimer: ReturnType<typeof setInterval> | null = null
+
+function startWatchdog(): void {
+  if (watchdogTimer) return // only one timer
+  watchdogTimer = setInterval(() => {
+    const idle = Date.now() - lastPongAt
+    if (idle > 180 * 1000) {
+      log(`[watchdog] no WS pong for ${Math.round(idle / 1000)}s, triggering reconnect`)
+      reconnectWs()
+    }
+  }, 30 * 1000)
 }
 
-// ── Card action handler ────────────────────────────────────────────────
-async function handleCardAction(data: any): Promise<any> {
-  const action = data?.action
-  const value = action?.value
-  if (!value?.kind) return
-  const chatId = data?.context?.open_chat_id ?? ''
-  const userId = data?.operator?.open_id ?? ''
-  const session = sessions.get(chatId)
-  if (!session) return { toast: { type: 'error', content: '会话不存在，请先发消息启动' } }
-
-  switch (value.kind) {
-    case 'permission':
-      await session.onPermissionDecision(value.request_id, value.decision, userId)
-      return { toast: { type: value.decision === 'deny' ? 'error' : 'success', content: '已处理' } }
-    case 'console':
-      await session.onConsoleAction(value.action)
-      return { toast: { type: 'info', content: value.action } }
-    case 'menu':
-      await session.onUserMessage(`(menu choice ${value.choice + 1})`)
-      return { toast: { type: 'success', content: 'OK' } }
-  }
-  return { toast: { type: 'info', content: 'unknown action' } }
-}
-
-// ── WebSocket boot ─────────────────────────────────────────────────────
-function fmt(m: any[]): string {
-  return m.map(x => typeof x === 'string' ? x : JSON.stringify(x)).join(' ')
-}
-
-async function boot(): Promise<void> {
-  log(`lodestar-daemon: pid ${process.pid} starting`)
-  feishu.loadSessionChatMap()
-  await feishu.refreshChatList()
-  setInterval(() => { void feishu.refreshChatList() }, 5 * 60 * 1000)
-
-  // Lark WSClient sends pings every ~120s but doesn't verify pongs. On a
-  // half-open TCP (NAT idle-kill, network blip) the socket stays OPEN and
-  // 'close' never fires — we'd go silently deaf. Stamp every inbound pong
-  // and exit(1) after 180s of silence so systemd reconnects us.
-  let lastPongAt = Date.now()
+function createWsClient(): { wsClient: lark.WSClient; dispatcher: lark.EventDispatcher } {
+  const fmt = (msg: any[]) =>
+    msg.map(m => typeof m === 'string' ? m : JSON.stringify(m)).join(' ')
+
   const wsLogger = {
-    error: (m: any[]) => log(`[ws-sdk error] ${fmt(m)}`),
-    warn:  (m: any[]) => log(`[ws-sdk warn] ${fmt(m)}`),
-    info:  (m: any[]) => log(`[ws-sdk] ${fmt(m)}`),
-    debug: (_m: any[]) => { /* drop */ },
-    trace: (m: any[]) => {
-      if (Array.isArray(m) && m[0] === '[ws]' && m[1] === 'receive pong') {
+    error: (msg: any[]) => log(`[ws-sdk error] ${fmt(msg)}`),
+    warn: (msg: any[]) => log(`[ws-sdk warn] ${fmt(msg)}`),
+    info: (msg: any[]) => log(`[ws-sdk] ${fmt(msg)}`),
+    debug: (_msg: any[]) => {},
+    trace: (msg: any[]) => {
+      if (Array.isArray(msg) && msg[0] === '[ws]' && msg[1] === 'receive pong') {
         lastPongAt = Date.now()
       }
     },
   }
-  setInterval(() => {
-    const idle = Date.now() - lastPongAt
-    if (idle > 180_000) {
-      log(`[watchdog] no WS pong for ${Math.round(idle / 1000)}s — exit for systemd restart`)
-      process.exit(1)
-    }
-  }, 30_000)
 
-  const ws = new lark.WSClient({
-    appId: config.feishu.app_id,
-    appSecret: config.feishu.app_secret,
-    loggerLevel: lark.LoggerLevel.trace,
+  const wsClient = new lark.WSClient({
+    appId: APP_ID!,
+    appSecret: APP_SECRET!,
+    loggerLevel: lark.LoggerLevel.info,
     logger: wsLogger,
   })
+
   const dispatcher = new lark.EventDispatcher({})
+
   dispatcher.register({
-    'im.message.receive_v1': async (d: any) => {
-      try { await handleMessage(d) } catch (e) { log(`handleMessage: ${e}`) }
+    'im.message.receive_v1': async (data: any) => {
+      try { await handleMessage(data) } catch (err) {
+        log(`handler error: ${err}`)
+      }
     },
   })
+
   dispatcher.register({
-    'card.action.trigger': async (d: any) => {
-      try { return await handleCardAction(d) } catch (e) { log(`handleCardAction: ${e}`) }
+    'card.action.trigger': async (data: any) => {
+      try { return await handleCardAction(data) } catch (err) {
+        log(`card action error: ${err}`)
+      }
     },
   })
-  ws.start({ eventDispatcher: dispatcher })
-  log(`lodestar-daemon: WS started, watching ${feishu.chatNameCache.size} groups`)
+
+  return { wsClient, dispatcher }
+}
+
+let wsClientInstance: lark.WSClient | null = null
+let wsReconnectAttempt = 0
+let wsReconnectTimer: ReturnType<typeof setTimeout> | null = null
+
+function startWs(): void {
+  startWatchdog()
+  const { wsClient, dispatcher } = createWsClient()
+  wsClientInstance = wsClient
+  wsClient.start({ eventDispatcher: dispatcher })
+  wsReconnectAttempt = 0
+  lastPongAt = Date.now()
+  log(`WS connected, watching ${chatNameCache.size} groups`)
+}
+
+function reconnectWs(): void {
+  if (wsReconnectTimer) return // already scheduled
+
+  // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 32s, 60s (cap)
+  wsReconnectAttempt++
+  const delay = Math.min(1000 * Math.pow(2, wsReconnectAttempt - 1), 60_000)
+
+  log(`WS reconnect attempt ${wsReconnectAttempt} in ${delay}ms`)
+
+  // After 5 minutes of failed reconnects, send Feishu notification
+  if (wsReconnectAttempt >= 8) {
+    for (const [chatId] of chatNameCache) {
+      sendTextMessage(chatId, '⚠️ 飞书连接不稳定，正在重连...').catch(() => {})
+    }
+  }
+
+  wsReconnectTimer = setTimeout(() => {
+    wsReconnectTimer = null
+    try {
+      if (wsClientInstance) {
+        try { (wsClientInstance as any).stop?.() } catch {}
+      }
+      startWs()
+    } catch (err) {
+      log(`WS reconnect failed: ${err}`)
+      // Schedule next attempt
+      reconnectWs()
+    }
+  }, delay)
+}
+
+async function boot() {
+  writePid()
+  ensureStateDir()
+  log('starting...')
+
+  // Write runtime token for utility scripts
+  try {
+    const tokenFile = join(STATE_DIR, '.runtime_token')
+    if (API_TOKEN) writeFileSync(tokenFile, API_TOKEN)
+  } catch {}
+
+  // Inject feishu MCP config into ~/.deepseek/mcp.json
+  try {
+    injectFeishuMcpConfig()
+  } catch (err) {
+    log(`mcp config inject failed: ${err}`)
+  }
+
+  loadSessionChatMap()
+
+  // Check Runtime API health
+  const apiReady = await api.healthCheck()
+  if (!apiReady) {
+    log('WARNING: deepseek serve --http not reachable at ' + API_URL)
+    log('  daemon will start but threads cannot be created until serve is up')
+    log('  start with: deepseek serve --http --port 7878')
+  } else {
+    log(`deepseek serve --http ready at ${API_URL}`)
+  }
+
+  await refreshChatList()
+  setInterval(() => {
+    void refreshChatList()
+  }, 5 * 60 * 1000)
+
+  // Reconnect SSE for existing threads
+  for (const [sessionName, threadId] of threadMap.entries()) {
+    sseHandler.connect(threadId).catch(err =>
+      log(`SSE reconnect failed for ${threadId}: ${err}`))
+  }
+
+  // Start email worker
+  startEmailWorker(log, sendTextMessage, chatNameCache).catch(err =>
+    log(`email-worker boot failed: ${err}`))
+
+  // Start status dashboard
+  startStatusDashboard(log)
+
+  // Start WS connection
+  startWs()
+
+  log(`daemon running (pid ${process.pid}), watching for messages in ${chatNameCache.size} groups...`)
 }
 
-boot().catch(e => { log(`boot fatal: ${e}`); process.exit(1) })
+boot().catch(err => { log(`fatal: ${err}`); process.exit(1) })