@geekbeer/minion 2.62.0 → 2.67.1

package/core/api.js

@@ -86,10 +86,120 @@ async function sendHeartbeat(data) {
   })
 }
 
+/**
+ * Create a project thread (help or discussion) on HQ.
+ * @param {object} data - { project_id, title, description, thread_type?, mentions?, context? }
+ * @returns {Promise<{ thread: object }>}
+ */
+async function createHelpThread(data) {
+  return request('/help-threads', {
+    method: 'POST',
+    body: JSON.stringify(data),
+  })
+}
+
+/**
+ * Get open help threads in this minion's projects.
+ * @returns {Promise<{ threads: object[] }>}
+ */
+async function getOpenHelpThreads() {
+  return request('/help-threads/open')
+}
+
+/**
+ * Get a help thread by ID with messages.
+ * @param {string} threadId
+ * @returns {Promise<{ thread: object, messages: object[] }>}
+ */
+async function getHelpThread(threadId) {
+  return request(`/help-threads/${threadId}`)
+}
+
+/**
+ * Post a message to a help thread.
+ * @param {string} threadId
+ * @param {object} data - { content, attachments?, mentions? }
+ */
+async function postHelpMessage(threadId, data) {
+  return request(`/help-threads/${threadId}/messages`, {
+    method: 'POST',
+    body: JSON.stringify(data),
+  })
+}
+
+/**
+ * Resolve a help thread.
+ * @param {string} threadId
+ * @param {string} resolution
+ */
+async function resolveHelpThread(threadId, resolution) {
+  return request(`/help-threads/${threadId}/resolve`, {
+    method: 'PATCH',
+    body: JSON.stringify({ resolution }),
+  })
+}
+
+/**
+ * Cancel a help thread.
+ * @param {string} threadId
+ * @param {string} [reason]
+ */
+async function cancelHelpThread(threadId, reason) {
+  return request(`/help-threads/${threadId}/cancel`, {
+    method: 'PATCH',
+    body: JSON.stringify({ reason: reason || null }),
+  })
+}
+
+/**
+ * Permanently delete a help thread (PM only).
+ * @param {string} threadId
+ */
+async function deleteHelpThread(threadId) {
+  return request(`/help-threads/${threadId}`, {
+    method: 'DELETE',
+  })
+}
+
+/**
+ * Create a project memory entry.
+ * @param {object} data - { project_id, title, content, category, tags?, source_thread_id? }
+ */
+async function createProjectMemory(data) {
+  return request('/project-memories', {
+    method: 'POST',
+    body: JSON.stringify(data),
+  })
+}
+
+/**
+ * Search project memories.
+ * @param {string} projectId
+ * @param {object} [opts] - { search?, category?, tags?, status? }
+ */
+async function searchProjectMemories(projectId, opts = {}) {
+  const params = new URLSearchParams({ project_id: projectId })
+  if (opts.search) params.set('search', opts.search)
+  if (opts.category) params.set('category', opts.category)
+  if (opts.tags) params.set('tags', opts.tags.join(','))
+  if (opts.status) params.set('status', opts.status)
+  return request(`/project-memories?${params.toString()}`)
+}
+
 module.exports = {
   request,
   reportExecution,
   reportStepComplete,
   reportIssue,
   sendHeartbeat,
+  createHelpThread,
+  getOpenHelpThreads,
+  getHelpThread,
+  postHelpMessage,
+  resolveHelpThread,
+
+  cancelHelpThread,
+  deleteHelpThread,
+  createProjectMemory,
+  searchProjectMemories,
 }

package/core/lib/config-warnings.js

@@ -0,0 +1,85 @@
+/**
+ * Config Warnings - checks for missing required configurations
+ *
+ * Computes a list of warning objects that indicate missing or misconfigured
+ * settings that prevent the minion from functioning properly.
+ * Results are included in heartbeat payloads so HQ can display them on the dashboard.
+ *
+ * Warning categories:
+ * - llm_not_authenticated: No LLM service is authenticated (Claude/Gemini/Codex)
+ * - llm_command_not_set: LLM_COMMAND is not configured (required for workflow/routine execution)
+ * - tunnel_not_running: Cloudflare tunnel is not running (required for VNC/terminal access)
+ */
+
+const { execSync } = require('child_process')
+const { config } = require('../config')
+const { getLlmServices, isLlmCommandConfigured } = require('./llm-checker')
+const { IS_WINDOWS } = require('./platform')
+
+/**
+ * Check if Cloudflare tunnel is running.
+ * @returns {boolean}
+ */
+function isTunnelRunning() {
+  try {
+    if (IS_WINDOWS) {
+      const out = execSync('tasklist /FI "IMAGENAME eq cloudflared.exe" /NH', {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: 'pipe',
+      })
+      return out.toLowerCase().includes('cloudflared.exe')
+    } else {
+      execSync('pgrep -f "cloudflared"', {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: 'pipe',
+      })
+      return true
+    }
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Compute config warnings for the current minion state.
+ * Each warning is an object with:
+ * - code: string identifier (e.g. 'llm_not_authenticated')
+ * - message: human-readable description (Japanese)
+ *
+ * @returns {{ code: string, message: string }[]}
+ */
+function getConfigWarnings() {
+  const warnings = []
+
+  // Check LLM authentication
+  const services = getLlmServices()
+  const hasAuthenticatedLlm = services.some(s => s.authenticated)
+  if (!hasAuthenticatedLlm) {
+    warnings.push({
+      code: 'llm_not_authenticated',
+      message: 'LLM\u304C\u672A\u8A8D\u8A3C\u3067\u3059\u3002Claude/Gemini/Codex\u306E\u3044\u305A\u308C\u304B\u3092\u8A8D\u8A3C\u3057\u3066\u304F\u3060\u3055\u3044',
+    })
+  }
+
+  // Check LLM_COMMAND
+  if (!isLlmCommandConfigured()) {
+    warnings.push({
+      code: 'llm_command_not_set',
+      message: 'LLM_COMMAND\u304C\u672A\u8A2D\u5B9A\u3067\u3059\u3002\u30EF\u30FC\u30AF\u30D5\u30ED\u30FC/\u30EB\u30FC\u30C6\u30A3\u30F3\u5B9F\u884C\u306B\u5FC5\u8981\u3067\u3059',
+    })
+  }
+
+  // Check tunnel (only for HQ-connected minions)
+  if (config.HQ_URL && !isTunnelRunning()) {
+    warnings.push({
+      code: 'tunnel_not_running',
+      message: 'Cloudflare\u30C8\u30F3\u30CD\u30EB\u304C\u505C\u6B62\u3057\u3066\u3044\u307E\u3059\u3002VNC/\u30BF\u30FC\u30DF\u30CA\u30EB\u63A5\u7D9A\u304C\u3067\u304D\u307E\u305B\u3093',
+    })
+  }
+
+  return warnings
+}
+
+module.exports = { getConfigWarnings }

package/core/lib/reflection-scheduler.js

@@ -156,13 +156,9 @@ async function runReflection() {
  * @returns {{ enabled: boolean, reflection_time: string, timezone: string, next_run: string|null }}
  */
 function getStatus() {
-  const reflectionTime = config.REFLECTION_TIME || ''
   const nextRun = cronJob ? cronJob.nextRun() : null
-
   return {
-    enabled: !!cronJob,
-    reflection_time: reflectionTime,
-    timezone: getSystemTimezone(),
+    running: !!cronJob,
     next_run: nextRun ? nextRun.toISOString() : null,
   }
 }

package/core/lib/revision-watcher.js

@@ -22,6 +22,9 @@ const POLL_INTERVAL_MS = 30_000
 let polling = false
 let pollTimer = null
 
+// Last successful poll timestamp
+let lastPollAt = null
+
 // Track revisions being processed to avoid duplicate handling
 const processingRevisions = new Set()
 
@@ -63,6 +66,7 @@ async function pollOnce() {
     }
   } finally {
     polling = false
+    lastPollAt = new Date().toISOString()
   }
 }
 
@@ -249,4 +253,11 @@ function stop() {
   }
 }
 
-module.exports = { start, stop, pollOnce }
+function getStatus() {
+  return {
+    running: pollTimer !== null,
+    last_poll_at: lastPollAt,
+  }
+}
+
+module.exports = { start, stop, pollOnce, getStatus }

package/core/lib/step-poller.js

@@ -33,6 +33,9 @@ let pollTimer = null
 // Track currently executing step to avoid double-dispatch
 let activeStepExecutionId = null
 
+// Last successful poll timestamp
+let lastPollAt = null
+
 /**
  * Poll HQ for pending steps and execute them.
  */
@@ -73,6 +76,7 @@ async function pollOnce() {
     }
   } finally {
     polling = false
+    lastPollAt = new Date().toISOString()
   }
 }
 
@@ -224,4 +228,11 @@ function stop() {
   }
 }
 
-module.exports = { start, stop, pollOnce }
+function getStatus() {
+  return {
+    running: pollTimer !== null,
+    last_poll_at: lastPollAt,
+  }
+}
+
+module.exports = { start, stop, pollOnce, getStatus }

package/core/lib/thread-watcher.js

@@ -0,0 +1,359 @@
+/**
+ * Project Thread Watcher
+ *
+ * Polling daemon that monitors open help/discussion threads in the minion's
+ * projects. Uses LLM to decide whether to participate in conversations.
+ *
+ * Token-saving strategies:
+ * 1. Read tracking: only evaluate threads with new messages since last check
+ * 2. Mention targeting: if thread/message has mentions, only targeted minions evaluate
+ * 3. Rate limiting: max 1 LLM evaluation per thread per 5 minutes
+ *
+ * Flow per poll cycle:
+ * 1. GET /api/minion/help-threads/open → list of open threads
+ * 2. For each thread with new activity:
+ *    a. Check mentions → if mentioned, must evaluate
+ *    b. Check read state → skip if no new messages
+ *    c. Fetch thread detail + messages
+ *    d. LLM evaluates relevance + generates response if appropriate
+ */
+
+const { config, isHqConfigured, isLlmConfigured } = require('../config')
+const api = require('../api')
+
+// Poll every 15 seconds
+const POLL_INTERVAL_MS = 15_000
+
+// Minimum interval between LLM evaluations for the same thread (5 minutes)
+const EVAL_COOLDOWN_MS = 5 * 60 * 1000
+
+// Prevent concurrent poll cycles
+let polling = false
+let pollTimer = null
+
+// Injected LLM function (set via start())
+let llmCallFn = null
+
+// Last successful poll timestamp
+let lastPollAt = null
+
+// Read tracking: threadId → { lastMessageCount, lastEvalAt }
+const readState = new Map()
+
+/**
+ * Get minion's role and project memberships for context.
+ * Cached per poll cycle.
+ */
+let cachedProjects = null
+let cachedProjectsAt = 0
+
+async function getMyProjects() {
+  // Cache for 60 seconds
+  if (cachedProjects && Date.now() - cachedProjectsAt < 60_000) {
+    return cachedProjects
+  }
+  try {
+    const data = await api.request('/me/projects')
+    cachedProjects = data.projects || []
+    cachedProjectsAt = Date.now()
+    return cachedProjects
+  } catch {
+    return cachedProjects || []
+  }
+}
+
+/**
+ * Check if this minion is mentioned in a thread or its messages.
+ * Mention formats: 'role:engineer', 'role:pm', 'minion:<minion_id>'
+ *
+ * @param {object} thread
+ * @param {object[]} messages - Only new messages to check
+ * @param {string} myRole - This minion's role in the project
+ * @returns {boolean}
+ */
+function isMentioned(thread, messages, myRole) {
+  const myMinionId = config.MINION_ID
+  const targets = [
+    `role:${myRole}`,
+    `minion:${myMinionId}`,
+  ]
+
+  // Check thread-level mentions
+  if (thread.mentions?.some(m => targets.includes(m))) return true
+
+  // Check message-level mentions
+  for (const msg of messages) {
+    if (msg.mentions?.some(m => targets.includes(m))) return true
+  }
+
+  return false
+}
+
+/**
+ * Poll for open threads and evaluate new activity.
+ */
+async function pollOnce() {
+  if (!isHqConfigured()) return
+  if (polling) return
+
+  polling = true
+  try {
+    const data = await api.request('/help-threads/open')
+
+    if (!data.threads || data.threads.length === 0) {
+      return
+    }
+
+    const now = Date.now()
+    const myProjects = await getMyProjects()
+
+    for (const thread of data.threads) {
+      try {
+        await processThread(thread, myProjects, now)
+      } catch (err) {
+        console.error(`[ThreadWatcher] Error processing thread ${thread.id}: ${err.message}`)
+      }
+    }
+  } catch (err) {
+    if (err.message?.includes('fetch failed') || err.message?.includes('ECONNREFUSED')) {
+      // HQ unreachable — silent retry
+    } else {
+      console.error(`[ThreadWatcher] Poll error: ${err.message}`)
+    }
+  } finally {
+    polling = false
+    lastPollAt = new Date().toISOString()
+  }
+}
+
+/**
+ * Process a single thread: check for new activity and evaluate if needed.
+ */
+async function processThread(thread, myProjects, now) {
+  // Find my role in this project
+  const myProject = myProjects.find(p => p.id === thread.project_id)
+  if (!myProject) return // Not a member
+
+  const state = readState.get(thread.id) || { lastMessageCount: 0, lastEvalAt: 0 }
+
+  // Fetch thread detail to get message count and check for new messages
+  let detail
+  try {
+    detail = await api.request(`/help-threads/${thread.id}`)
+  } catch {
+    return
+  }
+
+  const messages = detail.messages || []
+  const messageCount = messages.length
+
+  // Skip if no new messages since last check
+  if (messageCount <= state.lastMessageCount) {
+    return
+  }
+
+  // New messages detected
+  const newMessages = messages.slice(state.lastMessageCount)
+
+  // Update read state (message count only — eval timestamp updated after LLM call)
+  readState.set(thread.id, { ...state, lastMessageCount: messageCount })
+
+  // Check mentions first (no LLM needed to decide relevance)
+  const mentioned = isMentioned(thread, newMessages, myProject.role)
+
+  // If not mentioned and cooldown not expired, skip LLM evaluation
+  if (!mentioned && now - state.lastEvalAt < EVAL_COOLDOWN_MS) {
+    return
+  }
+
+  // If LLM is not configured, fall back to memory-only matching
+  if (!llmCallFn || !isLlmConfigured()) {
+    await fallbackMemoryMatch(thread, messages)
+    readState.set(thread.id, { lastMessageCount: messageCount, lastEvalAt: now })
+    return
+  }
+
+  // LLM evaluation
+  await evaluateWithLlm(thread, detail.thread, messages, newMessages, myProject, mentioned)
+  readState.set(thread.id, { lastMessageCount: messageCount, lastEvalAt: now })
+}
+
+/**
+ * Use LLM to evaluate thread and potentially respond.
+ */
+async function evaluateWithLlm(threadSummary, threadDetail, allMessages, newMessages, myProject, mentioned) {
+  // Build conversation context (limit to last 20 messages to control tokens)
+  const recentMessages = allMessages.slice(-20)
+  const messageHistory = recentMessages
+    .map(m => {
+      const sender = m.sender_minion_id
+        ? (m.sender_minion_id === config.MINION_ID ? 'You' : `Minion(${m.sender_minion_id.slice(0, 8)})`)
+        : 'User'
+      return `[${sender}] ${m.content}`
+    })
+    .join('\n')
+
+  const threadType = threadDetail.thread_type || 'help'
+  const mentionNote = mentioned
+    ? '\n\nあなたはこのスレッドでメンションされています。必ず返信してください。'
+    : ''
+
+  // Extract optional context metadata
+  const ctx = threadDetail.context || {}
+  const contextInfo = [
+    ctx.category ? `カテゴリ: ${ctx.category}` : '',
+    ctx.attempted_resolution ? `試行済み: ${ctx.attempted_resolution}` : '',
+  ].filter(Boolean).join('\n')
+
+  const prompt = `あなたはプロジェクト「${myProject.name}」のチームメンバー（ロール: ${myProject.role}）です。
+以下のスレッドに対して、あなたが返信すべきかどうかを判断し、返信する場合はその内容を生成してください。
+
+スレッドタイプ: ${threadType}
+タイトル: ${threadDetail.title}
+説明: ${threadDetail.description}
+${contextInfo}${mentionNote}
+
+--- メッセージ履歴 ---
+${messageHistory || '(メッセージなし)'}
+--- 履歴ここまで ---
+
+以下のJSON形式で回答してください:
+{
+  "should_respond": true/false,
+  "reason": "判断の理由（1行）",
+  "response": "返信内容（should_respondがtrueの場合のみ）"
+}
+
+判断基準:
+- 自分のロール（${myProject.role}）に関連する話題か
+- 自分が貢献できる知見や意見があるか
+- 既に十分な回答がある場合は重複を避ける
+- メンションされている場合は必ず返信する
+- 人間に聞くべき場合は @user メンションを含めて返信する`
+
+  try {
+    const result = await llmCallFn(prompt)
+
+    let parsed
+    try {
+      // LLM may return JSON wrapped in markdown code block
+      const cleaned = result.replace(/```json?\n?/g, '').replace(/```/g, '').trim()
+      parsed = JSON.parse(cleaned)
+    } catch {
+      console.log(`[ThreadWatcher] LLM returned non-JSON for thread ${threadSummary.id}, skipping`)
+      return
+    }
+
+    if (parsed.should_respond && parsed.response) {
+      // Check if the response contains @user mention
+      const mentions = []
+      if (parsed.response.includes('@user')) {
+        mentions.push('user')
+      }
+
+      await api.request(`/help-threads/${threadSummary.id}/messages`, {
+        method: 'POST',
+        body: JSON.stringify({
+          content: parsed.response,
+          mentions,
+        }),
+      })
+      console.log(`[ThreadWatcher] Responded to thread "${threadDetail.title}" (reason: ${parsed.reason})`)
+    } else {
+      console.log(`[ThreadWatcher] Skipped thread "${threadDetail.title}" (reason: ${parsed.reason || 'not relevant'})`)
+    }
+  } catch (err) {
+    console.error(`[ThreadWatcher] LLM evaluation failed for thread ${threadSummary.id}: ${err.message}`)
+  }
+}
+
+/**
+ * Fallback: memory-only matching when LLM is not available.
+ */
+async function fallbackMemoryMatch(thread) {
+  try {
+    const ctx = thread.context || {}
+    const category = ctx.category || ''
+    const searchParam = category ? `&category=${category}` : ''
+    const memData = await api.request(
+      `/project-memories?project_id=${thread.project_id}${searchParam}`
+    )
+
+    if (!memData.memories || memData.memories.length === 0) return
+
+    const keywords = (thread.title + ' ' + thread.description)
+      .toLowerCase()
+      .split(/[\s,.\-_/]+/)
+      .filter(w => w.length >= 3)
+      .filter((w, i, arr) => arr.indexOf(w) === i)
+      .slice(0, 10)
+
+    const relevant = memData.memories.filter(m =>
+      keywords.some(kw =>
+        m.title.toLowerCase().includes(kw) ||
+        m.content.toLowerCase().includes(kw)
+      )
+    )
+
+    if (relevant.length === 0) return
+
+    const knowledgeSummary = relevant
+      .map(m => `[${m.title}] ${m.content}`)
+      .join('\n\n')
+
+    await api.request(`/help-threads/${thread.id}/messages`, {
+      method: 'POST',
+      body: JSON.stringify({
+        content: `関連するプロジェクトメモリーが見つかりました:\n\n${knowledgeSummary}`,
+      }),
+    })
+
+    console.log(`[ThreadWatcher] Posted ${relevant.length} relevant memories for thread ${thread.id}`)
+  } catch (err) {
+    console.error(`[ThreadWatcher] Memory check failed for thread ${thread.id}: ${err.message}`)
+  }
+}
+
+/**
+ * Start the thread watcher daemon.
+ * @param {Function} runQuickLlmCall - LLM function for evaluating threads
+ */
+function start(runQuickLlmCall) {
+  llmCallFn = runQuickLlmCall || null
+
+  if (!isHqConfigured()) {
+    console.log('[ThreadWatcher] HQ not configured, thread watcher disabled')
+    return
+  }
+
+  if (!llmCallFn) {
+    console.log('[ThreadWatcher] LLM not available, using memory-only matching')
+  }
+
+  // Initial poll after a short delay
+  setTimeout(() => pollOnce(), 8000)
+
+  // Periodic polling
+  pollTimer = setInterval(() => pollOnce(), POLL_INTERVAL_MS)
+  console.log(`[ThreadWatcher] Started (polling every ${POLL_INTERVAL_MS / 1000}s)`)
+}
+
+/**
+ * Stop the thread watcher daemon.
+ */
+function stop() {
+  if (pollTimer) {
+    clearInterval(pollTimer)
+    pollTimer = null
+    console.log('[ThreadWatcher] Stopped')
+  }
+}
+
+function getStatus() {
+  return {
+    running: pollTimer !== null,
+    last_poll_at: lastPollAt,
+  }
+}
+
+module.exports = { start, stop, pollOnce, getStatus }

package/core/routes/daemons.js

@@ -0,0 +1,34 @@
+/**
+ * Daemon status route
+ *
+ * GET /api/daemons/status - Returns the status of all background daemons
+ *
+ * No auth required (local CLI access, same as /api/health and /api/status).
+ * Requires opts.heartbeatStatus (injected from server.js) for heartbeat state.
+ */
+
+const stepPoller = require('../lib/step-poller')
+const revisionWatcher = require('../lib/revision-watcher')
+const threadWatcher = require('../lib/thread-watcher')
+const reflectionScheduler = require('../lib/reflection-scheduler')
+
+/**
+ * @param {import('fastify').FastifyInstance} fastify
+ * @param {{ heartbeatStatus: () => object }} opts
+ */
+async function daemonRoutes(fastify, opts) {
+  fastify.get('/api/daemons/status', async () => {
+    return {
+      success: true,
+      daemons: {
+        step_poller: stepPoller.getStatus(),
+        revision_watcher: revisionWatcher.getStatus(),
+        thread_watcher: threadWatcher.getStatus(),
+        reflection_scheduler: reflectionScheduler.getStatus(),
+        heartbeat: opts.heartbeatStatus ? opts.heartbeatStatus() : { running: false },
+      },
+    }
+  })
+}
+
+module.exports = { daemonRoutes }

package/core/routes/help-threads.js

@@ -0,0 +1,189 @@
+/**
+ * Project thread routes (local API on minion)
+ *
+ * Endpoints:
+ * - GET  /api/help-threads         - List open threads in minion's projects
+ * - POST /api/help-threads         - Create a new thread (proxied to HQ)
+ * - GET  /api/help-threads/:id     - Get thread detail with messages
+ * - POST /api/help-threads/:id/messages  - Post a message to a thread
+ * - POST /api/help-threads/:id/resolve   - Resolve a thread
+ * - POST /api/help-threads/:id/cancel    - Cancel a thread
+ * - DELETE /api/help-threads/:id   - Permanently delete a thread (PM only)
+ * - GET  /api/project-memories     - Search project memories
+ * - POST /api/project-memories     - Create a project memory
+ */
+
+const { verifyToken } = require('../lib/auth')
+const api = require('../api')
+
+/**
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function helpThreadRoutes(fastify) {
+  // List open threads
+  fastify.get('/api/help-threads', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const data = await api.getOpenHelpThreads()
+      return { success: true, threads: data.threads || [] }
+    } catch (error) {
+      console.error(`[HelpThreads] List error: ${error.message}`)
+      reply.code(500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Create thread
+  fastify.post('/api/help-threads', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const data = await api.createHelpThread(request.body)
+      return { success: true, thread: data.thread }
+    } catch (error) {
+      console.error(`[HelpThreads] Create error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Get thread detail
+  fastify.get('/api/help-threads/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const data = await api.getHelpThread(request.params.id)
+      return { success: true, thread: data.thread, messages: data.messages }
+    } catch (error) {
+      console.error(`[HelpThreads] Get error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Post message
+  fastify.post('/api/help-threads/:id/messages', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const data = await api.postHelpMessage(request.params.id, request.body)
+      return { success: true, message: data.message }
+    } catch (error) {
+      console.error(`[HelpThreads] Message error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Resolve thread
+  fastify.post('/api/help-threads/:id/resolve', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const { resolution } = request.body || {}
+      const data = await api.resolveHelpThread(request.params.id, resolution)
+      return { success: true, thread: data.thread }
+    } catch (error) {
+      console.error(`[HelpThreads] Resolve error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Permanently delete thread (PM only)
+  fastify.delete('/api/help-threads/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const data = await api.deleteHelpThread(request.params.id)
+      return { success: true, deleted: data.deleted }
+    } catch (error) {
+      console.error(`[HelpThreads] Delete error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Cancel thread
+  fastify.post('/api/help-threads/:id/cancel', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const { reason } = request.body || {}
+      const data = await api.cancelHelpThread(request.params.id, reason)
+      return { success: true, thread: data.thread }
+    } catch (error) {
+      console.error(`[HelpThreads] Cancel error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Search project memories
+  fastify.get('/api/project-memories', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const { project_id, search, category, tags, status } = request.query || {}
+      if (!project_id) {
+        reply.code(400)
+        return { success: false, error: 'project_id is required' }
+      }
+      const data = await api.searchProjectMemories(project_id, {
+        search,
+        category,
+        tags: tags ? tags.split(',') : undefined,
+        status,
+      })
+      return { success: true, memories: data.memories || [] }
+    } catch (error) {
+      console.error(`[ProjectMemories] Search error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+
+  // Create project memory
+  fastify.post('/api/project-memories', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const data = await api.createProjectMemory(request.body)
+      return { success: true, memory: data.memory }
+    } catch (error) {
+      console.error(`[ProjectMemories] Create error: ${error.message}`)
+      reply.code(error.statusCode || 500)
+      return { success: false, error: error.message }
+    }
+  })
+}
+
+module.exports = { helpThreadRoutes }

package/docs/api-reference.md

@@ -244,6 +244,174 @@ Supported `cli_type`: `claude-code`, `gemini`, `codex`
 
 Note: Claude Code の場合、書き込み先は `settings.local.json`（サーバー再起動時に上書きされない）。
 
+### Daemon Status (デーモン監視)
+
+バックグラウンドデーモンの稼働状態を確認する。
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/daemons/status` | 全デーモンのステータス一覧 |
+
+GET `/api/daemons/status` response:
+```json
+{
+  "success": true,
+  "daemons": {
+    "step_poller": { "running": true, "last_poll_at": "2026-03-19T15:30:00.000Z" },
+    "revision_watcher": { "running": true, "last_poll_at": "2026-03-19T15:30:05.000Z" },
+    "thread_watcher": { "running": true, "last_poll_at": "2026-03-19T15:29:52.000Z" },
+    "reflection_scheduler": { "running": true, "next_run": "2026-03-20T03:00:00.000Z" },
+    "heartbeat": { "running": true, "last_beat_at": "2026-03-19T15:30:10.000Z" }
+  }
+}
+```
+
+| Daemon | 概要 |
+|--------|------|
+| `step_poller` | ワークフローステップの取得・実行（30秒間隔） |
+| `revision_watcher` | リビジョン要求の検知（30秒間隔、PMのみ） |
+| `thread_watcher` | プロジェクトスレッドの監視・LLM評価（15秒間隔） |
+| `reflection_scheduler` | 1日1回の振り返り（cron） |
+| `heartbeat` | HQへのハートビート（30秒間隔） |
+
+### Project Threads (プロジェクトスレッド)
+
+プロジェクト内のコミュニケーションチャネル。ブロッカー共有やチーム議論に使う。
+リクエストは HQ にプロキシされる。
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/help-threads` | 参加プロジェクトのオープンスレッド一覧 |
+| POST | `/api/help-threads` | スレッドを起票 |
+| GET | `/api/help-threads/:id` | スレッド詳細 + メッセージ一覧 |
+| POST | `/api/help-threads/:id/messages` | スレッドにメッセージを投稿 |
+| POST | `/api/help-threads/:id/resolve` | スレッドを解決済みにする |
+| POST | `/api/help-threads/:id/cancel` | スレッドをキャンセル |
+| DELETE | `/api/help-threads/:id` | スレッドを完全削除（PMのみ） |
+
+POST `/api/help-threads` body (ヘルプスレッド起票):
+```json
+{
+  "project_id": "uuid",
+  "thread_type": "help",
+  "title": "ランサーズの2FA認証コードが必要",
+  "description": "ログイン時に2段階認証を要求された。メールで届く6桁コードの入力が必要。",
+  "mentions": ["role:pm"],
+  "context": {
+    "category": "auth",
+    "attempted_resolution": "保存済み認証情報で再ログイン試行済み、2FA必須"
+  }
+}
+```
+
+POST `/api/help-threads` body (ディスカッションスレッド起票):
+```json
+{
+  "project_id": "uuid",
+  "thread_type": "discussion",
+  "title": "デプロイ手順の確認",
+  "description": "本番デプロイ前にステージングで確認するフローに変えたい。意見ある？",
+  "mentions": ["role:engineer"]
+}
+```
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `project_id` | string | Yes | プロジェクト UUID |
+| `thread_type` | string | No | `help`（デフォルト）or `discussion` |
+| `title` | string | Yes | スレッドの要約 |
+| `description` | string | Yes | 詳細説明 |
+| `mentions` | string[] | No | メンション対象。形式: `role:engineer`, `role:pm`, `minion:<minion_id>`, `user` |
+| `context` | object | No | 任意のメタデータ（category, urgency, workflow_execution_id等） |
+
+**thread_type の違い:**
+- `help`: ブロッカー解決。`resolve` で解決
+- `discussion`: チーム内ディスカッション。`close` で完了
+
+**メンションルール:**
+- メンションされたミニオンは優先的にスレッドを評価する
+- メンションがない場合、全チームメンバーがLLMで関連性を判定してから参加
+- トークン消費を抑えるため、当事者が明確な場合はメンションを推奨
+- ミニオンが自力で解決できない場合、`@user` メンション付きで返信して人間に助けを求める
+
+POST `/api/help-threads/:id/messages` body:
+```json
+{
+  "content": "関連するプロジェクトメモリーが見つかりました: ...",
+  "mentions": ["user"]
+}
+```
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `content` | string | Yes | メッセージ本文 |
+| `attachments` | object | No | 添付ファイル情報（JSON） |
+| `mentions` | string[] | No | メンション対象 |
+
+POST `/api/help-threads/:id/resolve` body:
+```json
+{
+  "resolution": "ユーザーから2FAコード(123456)を受け取りログイン成功"
+}
+```
+
+POST `/api/help-threads/:id/cancel` body (optional):
+```json
+{
+  "reason": "誤って起票したため取り消し"
+}
+```
+
+スレッドのステータスは Supabase Realtime で配信されるため、ポーリングに加えて
+HQ ダッシュボードではリアルタイムに更新が表示される。
+
+### Project Memories (プロジェクト共有知識)
+
+プロジェクトレベルのチーム共有知識ベース。ヘルプスレッドの解決知見を蓄積して再利用する。
+リクエストは HQ にプロキシされる。
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/project-memories` | メモリー検索。Query: `?project_id=&search=&category=&tags=&status=` |
+| POST | `/api/project-memories` | メモリーを投稿 |
+
+GET Query Parameters:
+
+| Param | Required | Description |
+|-------|----------|-------------|
+| `project_id` | Yes | プロジェクト UUID |
+| `search` | No | タイトル・内容でのテキスト検索 |
+| `category` | No | カテゴリフィルター |
+| `tags` | No | タグフィルター（カンマ区切り） |
+| `status` | No | `active`（デフォルト）, `outdated`, `archived` |
+
+POST `/api/project-memories` body:
+```json
+{
+  "project_id": "uuid",
+  "title": "ランサーズは2FA必須",
+  "content": "ランサーズはログイン時に2段階認証を要求する。メールで届くコードが必要なため、人間へのエスカレーションが必須。team_timeout=30sが適切。",
+  "category": "auth",
+  "tags": ["lancers", "2fa", "login"],
+  "source_thread_id": "uuid"
+}
+```
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `project_id` | string | Yes | プロジェクト UUID |
+| `title` | string | Yes | 知見のタイトル |
+| `content` | string | Yes | 知見の内容 |
+| `category` | string | Yes | `auth`, `environment`, `know-how`, `decision`, `preference` |
+| `tags` | string[] | No | 自由タグ（検索用） |
+| `source_thread_id` | string | No | 知見の出典ヘルプスレッド UUID |
+
+**推奨ワークフロー:**
+1. ブロッカー発生 → `GET /api/project-memories?project_id=...&category=auth&search=2fa` で既知の知見を検索
+2. 該当あり → 知見に基づいて自己解決 or 即エスカレーション
+3. 該当なし → `POST /api/help-threads` でブロッカー起票
+4. 解決後 → `POST /api/project-memories` で知見を蓄積
+
 ### Commands
 
 | Method | Endpoint | Description |
@@ -601,3 +769,30 @@ Response:
 | POST | `/api/minion/skills` | スキル登録/更新（新バージョン自動作成） |
 
 スキルはバージョン管理される。push ごとに新バージョンが作成され、ファイルは Supabase Storage に保存される。
+
+### Help Threads (HQ)
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/minion/help-threads` | ブロッカースレッドを起票 |
+| GET | `/api/minion/help-threads/open` | 参加プロジェクトの未解決スレッド一覧 |
+| GET | `/api/minion/help-threads/:id` | スレッド詳細 + メッセージ一覧 |
+| POST | `/api/minion/help-threads/:id/messages` | スレッドにメッセージを投稿 |
+| PATCH | `/api/minion/help-threads/:id/resolve` | スレッドを解決済みにする。Body: `{resolution}` |
+| PATCH | `/api/minion/help-threads/:id/cancel` | スレッドをキャンセル。Body: `{reason?}` |
+| DELETE | `/api/minion/help-threads/:id` | スレッドを完全削除（PMのみ）。メッセージもCASCADE削除 |
+| PATCH | `/api/minion/help-threads/:id/escalate` | スレッドを手動エスカレーション |
+
+ローカルエージェントの `/api/help-threads` は上記 HQ API へのプロキシ。
+詳細なリクエスト/レスポンス仕様はローカル API セクションの「Help Threads」を参照。
+
+### Project Memories (HQ)
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/minion/project-memories` | プロジェクトメモリーを投稿 |
+| GET | `/api/minion/project-memories` | メモリー検索。Query: `?project_id=&search=&category=&tags=&status=` |
+| PATCH | `/api/minion/project-memories/:id` | メモリーを更新。Body: `{title?, content?, category?, tags?, status?}` |
+
+ローカルエージェントの `/api/project-memories` は上記 HQ API へのプロキシ。
+詳細なリクエスト/レスポンス仕様はローカル API セクションの「Project Memories」を参照。

package/linux/minion-cli.sh

@@ -12,6 +12,7 @@
 #   sudo minion-cli restart                  # Restart agent service (root)
 #   minion-cli status                        # Get current status
 #   minion-cli health                        # Health check
+#   minion-cli daemons                       # Daemon status
 #   minion-cli diagnose                      # Run full service diagnostics
 #   minion-cli set-status busy "Running X"   # Set status and task
 #   minion-cli set-status online             # Set status only
@@ -814,6 +815,7 @@ CFEOF
   echo "Useful commands:"
   echo "  minion-cli status                     # Agent status"
   echo "  minion-cli health                     # Health check"
+  echo "  minion-cli daemons                    # Daemon status"
   echo "  sudo minion-cli restart               # Restart agent"
   echo "  sudo minion-cli stop                  # Stop agent"
   if [ "$PROC_MGR" = "systemd" ]; then
@@ -1219,6 +1221,10 @@ case "${1:-}" in
     curl -s "$AGENT_URL/api/health" | jq .
     ;;
 
+  daemons)
+    curl -s "$AGENT_URL/api/daemons/status" | jq .
+    ;;
+
   diagnose)
     echo "Running diagnostics..."
     echo ""

package/linux/server.js

@@ -43,6 +43,7 @@ const routineStore = require('../core/stores/routine-store')
 // Heartbeat interval: fixed at 30s (not user-configurable)
 const HEARTBEAT_INTERVAL_MS = 30_000
 let heartbeatTimer = null
+let lastBeatAt = null
 
 // Linux-specific modules
 const workflowRunner = require('./workflow-runner')
@@ -50,10 +51,14 @@ const routineRunner = require('./routine-runner')
 const { cleanupTtyd, killStaleTtydProcesses } = require('./routes/terminal')
 const { startTerminalProxy, stopTerminalProxy } = require('./terminal-proxy')
 
+// Config warnings (included in heartbeat)
+const { getConfigWarnings } = require('../core/lib/config-warnings')
+
 // Pull-model daemons (from core/)
 const stepPoller = require('../core/lib/step-poller')
 const revisionWatcher = require('../core/lib/revision-watcher')
 const reflectionScheduler = require('../core/lib/reflection-scheduler')
+const threadWatcher = require('../core/lib/thread-watcher')
 const runningTasks = require('../core/lib/running-tasks')
 
 // Shared routes (from core/)
@@ -68,6 +73,8 @@ const { memoryRoutes } = require('../core/routes/memory')
 const { dailyLogRoutes } = require('../core/routes/daily-logs')
 const { sudoersRoutes } = require('../core/routes/sudoers')
 const { permissionRoutes } = require('../core/routes/permissions')
+const { helpThreadRoutes } = require('../core/routes/help-threads')
+const { daemonRoutes } = require('../core/routes/daemons')
 
 // Linux-specific routes
 const { commandRoutes, getProcessManager, getAllowedCommands } = require('./routes/commands')
@@ -113,6 +120,7 @@ async function shutdown(signal) {
   stepPoller.stop()
   revisionWatcher.stop()
   reflectionScheduler.stop()
+  threadWatcher.stop()
   workflowRunner.stopAll()
   routineRunner.stopAll()
 
@@ -270,6 +278,8 @@ async function registerAllRoutes(app) {
   await app.register(dailyLogRoutes)
   await app.register(sudoersRoutes)
   await app.register(permissionRoutes)
+  await app.register(helpThreadRoutes)
+  await app.register(daemonRoutes, { heartbeatStatus: () => ({ running: !!heartbeatTimer, last_beat_at: lastBeatAt }) })
 
   // Linux-specific routes
   await app.register(commandRoutes)
@@ -353,14 +363,16 @@ async function start() {
       // Send initial online heartbeat
       const { getStatus } = require('../core/routes/health')
       const { currentTask } = getStatus()
-      sendHeartbeat({ status: 'online', current_task: currentTask, running_tasks: runningTasks.getAll(), version }).catch(err => {
+      sendHeartbeat({ status: 'online', current_task: currentTask, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), version }).catch(err => {
         console.error('[Heartbeat] Initial heartbeat failed:', err.message)
       })
 
       // Start periodic heartbeat
       heartbeatTimer = setInterval(() => {
         const { currentStatus, currentTask } = getStatus()
-        sendHeartbeat({ status: currentStatus, current_task: currentTask, running_tasks: runningTasks.getAll(), version }).catch(err => {
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), version }).then(() => {
+          lastBeatAt = new Date().toISOString()
+        }).catch(err => {
           console.error('[Heartbeat] Periodic heartbeat failed:', err.message)
         })
       }, HEARTBEAT_INTERVAL_MS)
@@ -369,6 +381,7 @@ async function start() {
       // Start Pull-model daemons
       stepPoller.start()
       revisionWatcher.start()
+      threadWatcher.start(runQuickLlmCall)
     } else {
       console.log('[Server] Running in standalone mode (no HQ connection)')
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekbeer/minion",
-  "version": "2.62.0",
+  "version": "2.67.1",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "linux/server.js",
   "bin": {

package/win/lib/process-manager.js

@@ -54,10 +54,10 @@ function detectProcessManager() {
  * @param {string} startCmd - Command/script block to start the agent
  * @returns {string} - Path to the generated update script (.ps1)
  */
-function buildUpdateScript(npmInstallCmd, stopCmd, startCmd) {
+function buildUpdateScript(npmInstallCmd, stopCmd, startCmd, scriptName = 'update-agent') {
   const dataDir = path.join(os.homedir(), '.minion')
-  const scriptPath = path.join(dataDir, 'update-agent.ps1')
-  const logPath = path.join(dataDir, 'update-agent.log')
+  const scriptPath = path.join(dataDir, `${scriptName}.ps1`)
+  const logPath = path.join(dataDir, `${scriptName}.log`)
 
   // PowerShell script content: stop → install → start, with logging
   // The stopCmd kills all child processes of the agent. Since this script
@@ -136,6 +136,7 @@ function buildAllowedCommands(procMgr) {
         'npm install -g @geekbeer/minion@latest --registry http://verdaccio:4873',
         stopBlock,
         startBlock,
+        'update-agent-dev',
       )]],
       deferred: true,
     }
@@ -164,6 +165,7 @@ function buildAllowedCommands(procMgr) {
         'npm install -g @geekbeer/minion@latest --registry http://verdaccio:4873',
         'nssm stop minion-agent',
         'nssm start minion-agent',
+        'update-agent-dev',
       )]],
       deferred: true,
     }
@@ -196,6 +198,7 @@ function buildAllowedCommands(procMgr) {
         'npm install -g @geekbeer/minion@latest --registry http://verdaccio:4873',
         'net stop minion-agent',
         'net start minion-agent',
+        'update-agent-dev',
       )]],
       deferred: true,
     }

package/win/minion-cli.ps1

@@ -4,7 +4,7 @@
 #   minion-cli-win setup --hq-url https://... --minion-id <UUID> --api-token <TOKEN>
 #   minion-cli-win setup --setup-tunnel
 #   minion-cli-win uninstall [--keep-data]
-#   minion-cli-win start | stop | restart | status | health | diagnose | version | help
+#   minion-cli-win start | stop | restart | status | health | daemons | diagnose | version | help
 
 # Parse arguments manually to avoid issues with npm wrapper passing $args as array
 $Command = 'help'
@@ -18,7 +18,7 @@ $i = 0
 while ($i -lt $args.Count) {
     $arg = [string]$args[$i]
     switch -Regex ($arg) {
-        '^(setup|reconfigure|uninstall|start|stop|restart|status|health|diagnose|version|help)$' { $Command = $arg }
+        '^(setup|reconfigure|uninstall|start|stop|restart|status|health|daemons|diagnose|version|help)$' { $Command = $arg }
         '^(-v|--version)$' { $Command = 'version' }
         '^--hq-url$' { $i++; if ($i -lt $args.Count) { $HqUrl = [string]$args[$i] } }
         '^--minion-id$' { $i++; if ($i -lt $args.Count) { $MinionId = [string]$args[$i] } }
@@ -895,6 +895,7 @@ Remove-Item `$PidFile -Force -ErrorAction SilentlyContinue
     Write-Host "Useful commands:"
     Write-Host "  minion-cli-win status    # Agent status"
     Write-Host "  minion-cli-win health    # Health check"
+    Write-Host "  minion-cli-win daemons   # Daemon status"
     Write-Host "  minion-cli-win restart   # Restart agent"
     Write-Host "  minion-cli-win stop      # Stop agent"
     Write-Host "  Get-Content $(Join-Path $LogDir 'service-stdout.log') -Tail 50  # View logs"
@@ -1164,6 +1165,15 @@ switch ($Command) {
             Write-Error "Health check failed. Is the agent running?"
         }
     }
+    'daemons' {
+        try {
+            $response = Invoke-RestMethod -Uri "$AgentUrl/api/daemons/status" -TimeoutSec 5
+            $response | ConvertTo-Json -Depth 5
+        }
+        catch {
+            Write-Error "Failed to get daemon status. Is the agent running?"
+        }
+    }
     'diagnose' {
         Write-Host "Running diagnostics..."
         Write-Host ""

package/win/server.js

@@ -23,15 +23,20 @@ const routineStore = require('../core/stores/routine-store')
 // Heartbeat interval: fixed at 30s (not user-configurable)
 const HEARTBEAT_INTERVAL_MS = 30_000
 let heartbeatTimer = null
+let lastBeatAt = null
 
 // Windows-specific modules
 const workflowRunner = require('./workflow-runner')
 const routineRunner = require('./routine-runner')
 
+// Config warnings (included in heartbeat)
+const { getConfigWarnings } = require('../core/lib/config-warnings')
+
 // Pull-model daemons (from core/)
 const stepPoller = require('../core/lib/step-poller')
 const revisionWatcher = require('../core/lib/revision-watcher')
 const reflectionScheduler = require('../core/lib/reflection-scheduler')
+const threadWatcher = require('../core/lib/thread-watcher')
 const { commandRoutes, getProcessManager, getAllowedCommands } = require('./routes/commands')
 const { terminalRoutes, cleanupSessions } = require('./routes/terminal')
 const { startTerminalServer, stopTerminalServer } = require('./terminal-server')
@@ -51,6 +56,8 @@ const { variableRoutes } = require('../core/routes/variables')
 const { memoryRoutes } = require('../core/routes/memory')
 const { dailyLogRoutes } = require('../core/routes/daily-logs')
 const { permissionRoutes } = require('../core/routes/permissions')
+const { helpThreadRoutes } = require('../core/routes/help-threads')
+const { daemonRoutes } = require('../core/routes/daemons')
 
 // Validate configuration
 validate()
@@ -86,6 +93,7 @@ async function shutdown(signal) {
   stepPoller.stop()
   revisionWatcher.stop()
   reflectionScheduler.stop()
+  threadWatcher.stop()
   workflowRunner.stopAll()
   routineRunner.stopAll()
   stopTerminalServer()
@@ -203,6 +211,8 @@ async function registerRoutes(app) {
   await app.register(memoryRoutes)
   await app.register(dailyLogRoutes)
   await app.register(permissionRoutes)
+  await app.register(helpThreadRoutes)
+  await app.register(daemonRoutes, { heartbeatStatus: () => ({ running: !!heartbeatTimer, last_beat_at: lastBeatAt }) })
 
   // Windows-specific routes
   await app.register(commandRoutes)
@@ -284,14 +294,16 @@ async function start() {
       // Send initial online heartbeat
       const { getStatus } = require('../core/routes/health')
       const { currentTask } = getStatus()
-      sendHeartbeat({ status: 'online', current_task: currentTask, version }).catch(err => {
+      sendHeartbeat({ status: 'online', current_task: currentTask, config_warnings: getConfigWarnings(), version }).catch(err => {
         console.error('[Heartbeat] Initial heartbeat failed:', err.message)
       })
 
       // Start periodic heartbeat
       heartbeatTimer = setInterval(() => {
         const { currentStatus, currentTask } = getStatus()
-        sendHeartbeat({ status: currentStatus, current_task: currentTask, version }).catch(err => {
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, config_warnings: getConfigWarnings(), version }).then(() => {
+          lastBeatAt = new Date().toISOString()
+        }).catch(err => {
           console.error('[Heartbeat] Periodic heartbeat failed:', err.message)
         })
       }, HEARTBEAT_INTERVAL_MS)
@@ -300,6 +312,7 @@ async function start() {
       // Start Pull-model daemons
       stepPoller.start()
       revisionWatcher.start()
+      threadWatcher.start(runQuickLlmCall)
     } else {
       console.log('[Server] Running in standalone mode (no HQ connection)')
     }