@geekbeer/minion 2.60.0 → 2.67.0

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 }