@geekbeer/minion 3.58.0 → 3.59.2

package/core/meetings/meeting-mcp-server.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Meeting MCP server (stdio).
+ *
+ * Spawned by meeting-runner per meeting. Bridges the in-tmux claude process
+ * to the HQ meeting endpoints. Exposes four tools:
+ *
+ *   meeting_wait_for_next_message(timeout_ms?)
+ *     Long-polls HQ for new messages since the last call. Returns either
+ *     { messages: [...], history_count } or { meeting_ended: true }.
+ *
+ *   meeting_speak(text)
+ *     Posts a message to the meeting from this minion.
+ *
+ *   meeting_get_state()
+ *     Returns meeting metadata + participant list.
+ *
+ *   meeting_leave()
+ *     Records left_at for this minion. Returns { ok: true }; claude should
+ *     exit its participation loop after this call.
+ *
+ * Environment (passed by meeting-runner):
+ *   MINION_MEETING_ID   - meeting UUID
+ *   HQ_URL              - HQ server URL
+ *   API_TOKEN           - minion's API token (Bearer)
+ *
+ * Protocol: JSON-RPC 2.0 over stdio.
+ */
+
+const readline = require('readline')
+
+const HQ_URL = process.env.HQ_URL
+const API_TOKEN = process.env.API_TOKEN
+const MEETING_ID = process.env.MINION_MEETING_ID
+
+if (!HQ_URL || !API_TOKEN || !MEETING_ID) {
+  process.stderr.write('[meeting-mcp] Missing required env: HQ_URL / API_TOKEN / MINION_MEETING_ID\n')
+  process.exit(1)
+}
+
+let lastSeenAt = null
+
+async function hqFetch(path, options = {}) {
+  const url = `${HQ_URL}${path}`
+  const resp = await fetch(url, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${API_TOKEN}`,
+      ...(options.headers || {}),
+    },
+  })
+  let data = null
+  try {
+    data = await resp.json()
+  } catch {
+    data = {}
+  }
+  return { resp, data }
+}
+
+async function waitForNextMessage() {
+  const params = new URLSearchParams({ wait: 'true' })
+  if (lastSeenAt) params.set('after', lastSeenAt)
+  const { resp, data } = await hqFetch(
+    `/api/minion/meetings/${MEETING_ID}/messages?${params}`,
+  )
+  if (resp.status === 404 || data.meeting_ended) {
+    return { meeting_ended: true }
+  }
+  const messages = data.messages || []
+  if (messages.length > 0) {
+    lastSeenAt = messages[messages.length - 1].created_at
+  }
+  return { messages, history_count: messages.length }
+}
+
+async function speak(text) {
+  const { resp, data } = await hqFetch(
+    `/api/minion/meetings/${MEETING_ID}/messages`,
+    { method: 'POST', body: JSON.stringify({ text }) },
+  )
+  if (!resp.ok) {
+    throw new Error(data.error || `speak failed: ${resp.status}`)
+  }
+  return { message_id: data.message?.id }
+}
+
+async function getState() {
+  const { resp, data } = await hqFetch(`/api/minion/meetings/${MEETING_ID}`)
+  if (resp.status === 404) {
+    return { meeting_ended: true }
+  }
+  if (!resp.ok) {
+    throw new Error(data.error || `state failed: ${resp.status}`)
+  }
+  return data
+}
+
+async function leave() {
+  await hqFetch(`/api/minion/meetings/${MEETING_ID}`, {
+    method: 'POST',
+    body: JSON.stringify({ action: 'leave' }),
+  })
+  return { ok: true }
+}
+
+// --- Tool definitions --------------------------------------------------------
+
+function toolsList() {
+  return [
+    {
+      name: 'meeting_wait_for_next_message',
+      description:
+        'Long-poll for the next message in the meeting (up to ~25s). ' +
+        'Returns { messages: [...], history_count } when new messages arrive, ' +
+        'or { meeting_ended: true } if the meeting has been ended by the host. ' +
+        'Use this in a loop to listen to the meeting.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    },
+    {
+      name: 'meeting_speak',
+      description:
+        'Say something in the meeting. Your message will be visible to all participants. ' +
+        'Keep it conversational and short (1-3 sentences) unless the discussion requires depth.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          text: { type: 'string', description: 'What you want to say.' },
+        },
+        required: ['text'],
+      },
+    },
+    {
+      name: 'meeting_get_state',
+      description:
+        'Get meeting metadata (title, purpose, participants). Useful at session start.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+    {
+      name: 'meeting_leave',
+      description:
+        'Leave the meeting. Call this when the meeting is over or you have been ' +
+        'explicitly excused. After calling this, exit your participation loop.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+  ]
+}
+
+async function handleToolCall(name, args) {
+  switch (name) {
+    case 'meeting_wait_for_next_message':
+      return waitForNextMessage()
+    case 'meeting_speak':
+      return speak(String(args.text || ''))
+    case 'meeting_get_state':
+      return getState()
+    case 'meeting_leave':
+      return leave()
+    default:
+      throw new Error(`Unknown tool: ${name}`)
+  }
+}
+
+// --- JSON-RPC transport ------------------------------------------------------
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n')
+}
+
+function sendResult(id, result) {
+  send({ jsonrpc: '2.0', id, result })
+}
+
+function sendError(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } })
+}
+
+async function dispatch(msg) {
+  const { id, method, params } = msg
+  try {
+    switch (method) {
+      case 'initialize':
+        sendResult(id, {
+          protocolVersion: '2024-11-05',
+          serverInfo: { name: 'minion-meeting', version: '1.0.0' },
+          capabilities: { tools: {} },
+        })
+        return
+
+      case 'notifications/initialized':
+        return
+
+      case 'tools/list':
+        sendResult(id, { tools: toolsList() })
+        return
+
+      case 'tools/call': {
+        const { name, arguments: args } = params || {}
+        const result = await handleToolCall(name, args || {})
+        sendResult(id, {
+          content: [{ type: 'text', text: JSON.stringify(result) }],
+          isError: false,
+        })
+        return
+      }
+
+      case 'ping':
+        sendResult(id, {})
+        return
+
+      default:
+        if (id !== undefined) sendError(id, -32601, `Method not found: ${method}`)
+        return
+    }
+  } catch (err) {
+    if (id !== undefined) sendError(id, -32000, err.message || String(err))
+  }
+}
+
+function start() {
+  const rl = readline.createInterface({ input: process.stdin, terminal: false })
+  rl.on('line', (line) => {
+    const trimmed = line.trim()
+    if (!trimmed) return
+    let msg
+    try {
+      msg = JSON.parse(trimmed)
+    } catch {
+      return
+    }
+    dispatch(msg)
+  })
+  rl.on('close', () => process.exit(0))
+}
+
+if (require.main === module) {
+  start()
+}
+
+module.exports = { start, toolsList, handleToolCall }

package/core/meetings/meeting-prompt.js

@@ -0,0 +1,49 @@
+/**
+ * Build the kickoff prompt injected into the claude process when joining
+ * a meeting. The prompt:
+ *   1. Explains the meeting context (title, purpose, participants).
+ *   2. Instructs claude to use the meeting MCP tools to participate.
+ *   3. Hands control to claude to run its own participation loop.
+ *
+ * Output behavior (sprint plan, retro notes, etc.) is intentionally NOT
+ * hardcoded here — that lives in role-specific guidance (PM core.md etc.)
+ * so different meeting purposes can produce different artifacts.
+ */
+
+function buildMeetingKickoffPrompt({ meetingId, title, purpose, host, selfName, role }) {
+  const lines = [
+    `[ミーティング参加] [meeting:${meetingId}]`,
+    `あなたは「${selfName}」として、進行中のミーティングに招待されました。`,
+    '',
+    '## ミーティング情報',
+    `- タイトル: ${title}`,
+    purpose ? `- 目的: ${purpose}` : null,
+    host ? `- ホスト: ${host}` : null,
+    role ? `- あなたの役割: ${role}` : null,
+    '',
+    '## 参加方法',
+    'meeting MCP ツールを使って参加してください。基本ループ:',
+    '',
+    '1. `meeting_get_state` でミーティングの状態と参加者を確認',
+    '2. `meeting_wait_for_next_message` で次の発言を待つ (long-poll, 最大25秒)',
+    '3. 受け取ったメッセージに対して、応答すべきか判断する',
+    '   - 自分の役割・コンテキストに関連する話題なら応答する',
+    '   - 直前の発言が他の参加者宛 (mention) なら基本的にスルー',
+    '   - 重複・冗長な発言は避ける (他のミニオンが既に同趣旨を発言していたら追従しない)',
+    '4. 応答する場合は `meeting_speak` で 1-3 文の短い発言を送る',
+    '5. `meeting_wait_for_next_message` の戻り値が `{ meeting_ended: true }` になったら',
+    '   `meeting_leave` を呼んでループを終了する',
+    '',
+    '## 発言ガイドライン',
+    '- 1回の発言は **2-3 文以内** を基本とする (会議でだらだら話さない)',
+    '- 議論を前進させる発言を優先する (賛否・確認・代替案・質問)',
+    '- 既存のあなたのタスク・プロジェクト状況を知っていれば、それを踏まえて発言する',
+    '- 役割に応じた成果物がある場合 (PM=議事録/sprint計画 等) は、',
+    '  あなたの core ルールに従って終了前に作成する',
+    '',
+    'では `meeting_get_state` から開始してください。',
+  ].filter(Boolean)
+  return lines.join('\n')
+}
+
+module.exports = { buildMeetingKickoffPrompt }

package/core/routes/meetings.js

@@ -0,0 +1,111 @@
+/**
+ * Meetings routes (experimental)
+ *
+ * Receives meeting lifecycle pushes from HQ:
+ *   POST   /api/meetings/invitations   — HQ invites this minion to a meeting
+ *   DELETE /api/meetings/:id           — HQ notifies the meeting has ended
+ *   GET    /api/meetings/active        — Debug: list currently-active sessions
+ *
+ * The actual participation (waiting for messages, speaking) happens inside
+ * the spawned tmux session via the meeting MCP server — HQ never controls
+ * the minion's thoughts, it just opens and closes the meeting room.
+ *
+ * Platform-specific runner is dependency-injected via fastify opts so the
+ * same route module works on Linux (tmux) and Windows (WSL).
+ */
+
+const { verifyToken } = require('../lib/auth')
+
+async function meetingRoutes(fastify, opts) {
+  const meetingRunner = opts.meetingRunner
+  if (!meetingRunner) {
+    throw new Error('meetingRoutes requires { meetingRunner } in opts')
+  }
+
+  /**
+   * POST /api/meetings/invitations
+   * Body: { meeting_id, title, purpose, hq_url, host }
+   * Spawns a tmux session that runs claude with the meeting MCP server.
+   */
+  fastify.post('/api/meetings/invitations', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const body = request.body || {}
+    const { meeting_id, title, purpose, hq_url, host, self_name, role } = body
+    if (!meeting_id || !title || !hq_url) {
+      reply.code(400)
+      return {
+        success: false,
+        error: 'meeting_id, title, and hq_url are required',
+      }
+    }
+
+    try {
+      const result = await meetingRunner.runMeeting({
+        meetingId: meeting_id,
+        title,
+        purpose: purpose || null,
+        host: host || 'host',
+        hqUrl: hq_url,
+        selfName: self_name || null,
+        role: role || null,
+      })
+      if (!result.success) {
+        reply.code(500)
+        return { success: false, error: result.error || 'Failed to start meeting session' }
+      }
+      return {
+        success: true,
+        session_name: result.sessionName,
+        started: result.started,
+      }
+    } catch (err) {
+      console.error(`[Meetings] Failed to start meeting: ${err.message}`)
+      reply.code(500)
+      return { success: false, error: err.message }
+    }
+  })
+
+  /**
+   * DELETE /api/meetings/:id
+   * HQ notifies that the meeting has been ended/deleted. Kill the tmux session.
+   */
+  fastify.delete('/api/meetings/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+    const meetingId = request.params.id
+    try {
+      const killed = await meetingRunner.killMeetingSession(meetingId)
+      return { success: true, killed }
+    } catch (err) {
+      console.error(`[Meetings] Failed to kill meeting ${meetingId}: ${err.message}`)
+      reply.code(500)
+      return { success: false, error: err.message }
+    }
+  })
+
+  /**
+   * GET /api/meetings/active
+   * Debug: list active meeting tmux sessions.
+   */
+  fastify.get('/api/meetings/active', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+    try {
+      const sessions = await meetingRunner.listMeetingSessions()
+      return { success: true, sessions }
+    } catch (err) {
+      reply.code(500)
+      return { success: false, error: err.message }
+    }
+  })
+}
+
+module.exports = { meetingRoutes }

package/docs/api-reference.md

@@ -767,6 +767,18 @@ Web ページの読み取り・要約・情報抽出をミニオン内のサブ
 
 Available commands: `restart-agent`, `update-agent`, `restart-display`, `restart-all`, `status-services`
 
+### Meeting Rooms 🧪 (experimental, v3.59.0〜)
+
+HQ がミーティング招待を直接ミニオンへプッシュするエンドポイント。受信すると `mt-{meetingId8}` 名の tmux セッションを起動し、claude + meeting MCP サーバーで会議に参加する。
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/meetings/invitations` | HQからの招待受信。Body: `{meeting_id, title, purpose, hq_url, host, self_name?, role?}` |
+| DELETE | `/api/meetings/:id` | HQからの終了通知 (tmuxセッションkill) |
+| GET | `/api/meetings/active` | デバッグ: アクティブな会議セッション一覧 |
+
+参加後の動作 (`meeting` MCPツール) は core.md の「Meeting Participation」を参照。
+
 ### Admin (HQ → Minion only)
 
 HQ が課金状態の変化に応じてミニオンに直接プッシュするエンドポイント。
@@ -1974,3 +1986,16 @@ hq note list <project_id>
 hq note get <project_id> <note_id>
 hq note search <project_id> "キーワード"
 ```
+
+### Meeting Rooms 🧪 (HQ, experimental, v3.59.0〜)
+
+ミーティング機能はミニオン上の `meeting` MCP サーバーが叩く HQ エンドポイント。通常 AI 側から直接コールすることはなく、招待 (`POST /api/meetings/invitations` をミニオンが受信) で起動された claude セッションが MCP ツール経由で利用する。
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/minion/meetings/:id` | ミーティングのメタデータ + 参加者一覧。`meeting_get_state` ツールから呼ばれる |
+| GET | `/api/minion/meetings/:id/messages?after=<iso>&wait=true` | long-poll で次の発言を待機 (最大 ~25秒)。404 = 会議終了 |
+| POST | `/api/minion/meetings/:id/messages` | 発言。Body: `{text}` |
+| POST | `/api/minion/meetings/:id` | アクション。Body: `{action: 'leave' \| 'heartbeat'}` |
+
+これらは MCP ツール (`meeting_wait_for_next_message`, `meeting_speak`, `meeting_leave`) として claude に公開される。直接叩く必要はない。

package/docs/task-guides.md

@@ -793,6 +793,34 @@ await reportIssue({ title: '...', body: '...', labels: ['bug'] })
 
 ---
 
+## ミーティングへの参加 🧪 (experimental, v3.59.0〜)
+
+HQから招待されると、`mt-{meetingId8}` 名の tmux セッションで claude が自動起動して `meeting` MCP サーバー経由で会議に参加する。あなた自身がコマンドを叩いて参加・退出する必要は無い。
+
+**セッション中のあなたの責任:**
+
+1. `meeting_get_state` で目的・参加者を確認 (起動直後に呼ぶ)
+2. `meeting_wait_for_next_message` をループで呼んで発言を聞く
+3. 自分が応答すべき内容なら `meeting_speak` で発言 (1-3文)
+4. 戻り値が `meeting_ended: true` になったら `meeting_leave` を呼んでループ脱出
+
+**振る舞い指針:** core.md の「Meeting Participation」を参照。特に:
+- 発言は短く (会議でだらだら話さない)
+- 重複発言を避ける
+- 議論を前進させる発言を優先 (賛否・代替案・質問)
+- PMロールなら議事進行と成果物作成も担う
+
+**確認方法:**
+```bash
+# アクティブな会議セッションを確認
+tmux ls | grep '^mt-'
+
+# 自分が参加中の会議の状態
+curl -H "Authorization: Bearer $API_TOKEN" http://localhost:8080/api/meetings/active
+```
+
+セッション復帰機構は未実装。tmux/claude が落ちた場合は再起動されず、新しい招待を待つ。
+
 ## ツール・MCPサーバーのインストール
 
 スキルが `requires` で宣言している MCP サーバーや CLI ツールが不足している場合は、`~/.minion/docs/environment-setup.md` の手順に従ってインストールする。

package/linux/meeting-runner.js

@@ -0,0 +1,215 @@
+/**
+ * Meeting Runner (Linux)
+ *
+ * Spawns a dedicated tmux session per meeting invitation so the claude
+ * participation loop is isolated from chat / board-task sessions and can
+ * be inspected via `tmux attach -t mt-{id8}`.
+ *
+ * Session naming: `mt-{meetingId.slice(0,8)}`
+ *
+ * Lifecycle:
+ *   1. Receive invitation from HQ (via routes/meetings POST /api/meetings/invitations).
+ *   2. If a `mt-*` session for this meeting already exists, return early
+ *      (idempotent: HQ may retry pushes).
+ *   3. Write a temporary MCP config + kickoff prompt, then spawn:
+ *        tmux new-session -d -s mt-xxx claude --mcp-config <tmp> <kickoff>
+ *      The meeting MCP server starts as a stdio subprocess of claude.
+ *   4. tmux session exits when claude exits (after meeting_leave is called
+ *      or the meeting was deleted on HQ side).
+ *
+ * No exit-code polling here (unlike board-task-runner) — meetings are
+ * fire-and-forget; observability is via `tmux ls` + meeting logs.
+ */
+
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const fs = require('fs').promises
+const os = require('os')
+const path = require('path')
+const execAsync = promisify(exec)
+
+const { config } = require('../core/config')
+const runningTasks = require('../core/lib/running-tasks')
+const logManager = require('../core/lib/log-manager')
+const { getActivePrimary } = require('../core/llm-plugins/lib/active')
+const { buildMeetingKickoffPrompt } = require('../core/meetings/meeting-prompt')
+
+function generateSessionName(meetingId) {
+  if (!meetingId) throw new Error('meetingId is required')
+  return `mt-${String(meetingId).substring(0, 8)}`
+}
+
+async function tmuxHasSession(sessionName) {
+  try {
+    await execAsync(`tmux has-session -t "${sessionName}" 2>/dev/null`)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function listMeetingSessions() {
+  try {
+    const { stdout } = await execAsync(`tmux ls -F '#S' 2>/dev/null`)
+    return stdout
+      .split('\n')
+      .map((s) => s.trim())
+      .filter((s) => s.startsWith('mt-'))
+  } catch {
+    return []
+  }
+}
+
+async function killMeetingSession(meetingId) {
+  const sessionName = generateSessionName(meetingId)
+  try {
+    await execAsync(`tmux kill-session -t "${sessionName}" 2>/dev/null`)
+    runningTasks.remove(sessionName)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Start a meeting participation tmux session.
+ *
+ * @param {object} params
+ * @param {string} params.meetingId
+ * @param {string} params.title
+ * @param {string|null} params.purpose
+ * @param {string} params.host
+ * @param {string} params.hqUrl
+ * @param {string} [params.selfName] - This minion's display name
+ * @param {string} [params.role] - This minion's role in the project (e.g. 'pm')
+ */
+async function runMeeting({ meetingId, title, purpose, host, hqUrl, selfName, role }) {
+  if (!meetingId) {
+    return { sessionName: null, started: false, success: false, error: 'meetingId is required' }
+  }
+
+  const sessionName = generateSessionName(meetingId)
+
+  if (await tmuxHasSession(sessionName)) {
+    console.log(`[MeetingRunner] tmux session ${sessionName} already exists, skipping start`)
+    return { sessionName, started: false, success: true }
+  }
+
+  const promptFile = path.join(os.tmpdir(), `minion-meeting-prompt-${sessionName}.txt`)
+  const mcpConfigFile = path.join(os.tmpdir(), `minion-meeting-mcp-${sessionName}.json`)
+  const execScript = path.join(os.tmpdir(), `minion-meeting-exec-${sessionName}.sh`)
+  const mcpServerPath = path.join(__dirname, '..', 'core', 'meetings', 'meeting-mcp-server.js')
+
+  console.log(`[MeetingRunner] Starting meeting ${meetingId} (${title})`)
+  console.log(`[MeetingRunner] tmux session: ${sessionName}`)
+
+  try {
+    await logManager.ensureLogDir()
+
+    const prompt = buildMeetingKickoffPrompt({
+      meetingId,
+      title,
+      purpose,
+      host,
+      selfName: selfName || 'minion',
+      role: role || null,
+    })
+    await fs.writeFile(promptFile, prompt, 'utf-8')
+
+    // Use the minion's own config.HQ_URL — set correctly at provisioning time.
+    // For docker minions this is the docker-network internal URL
+    // (HQ_INTERNAL_URL=http://frontend-server:3000), which differs from
+    // browser-facing NEXT_PUBLIC_SITE_URL=http://localhost:3000. Falling back
+    // to the URL pushed by HQ only if local config is missing.
+    const effectiveHqUrl = config.HQ_URL || hqUrl
+    if (!effectiveHqUrl) {
+      throw new Error('No HQ_URL configured (neither minion config nor HQ push)')
+    }
+
+    // MCP config injecting our env into the meeting server child process
+    const mcpConfig = {
+      mcpServers: {
+        meeting: {
+          command: 'node',
+          args: [mcpServerPath],
+          env: {
+            HQ_URL: effectiveHqUrl,
+            API_TOKEN: config.API_TOKEN,
+            MINION_MEETING_ID: meetingId,
+          },
+        },
+      },
+    }
+    await fs.writeFile(mcpConfigFile, JSON.stringify(mcpConfig, null, 2), 'utf-8')
+
+    const primary = getActivePrimary()
+    if (!primary || primary.name !== 'claude') {
+      throw new Error(
+        'Meeting participation currently requires the claude primary LLM (MCP support). ' +
+          `Active primary: ${primary ? primary.name : 'none'}`,
+      )
+    }
+
+    // Build invocation directly to inject --mcp-config (not supported by
+    // buildShellInvocation, which is shared across plugins).
+    //
+    // --allowedTools: Claude Code defaults to prompting the user for every MCP
+    // tool call, which hangs in -p mode (no interactive UI). Pre-authorize the
+    // meeting MCP tools so claude can run the participation loop without
+    // approval prompts. We do NOT bypass permissions globally — built-in tools
+    // (Bash, Read, Write etc.) still go through the user's normal allow list.
+    const { resolveBinary } = require('../core/llm-plugins/lib/spawn-helper')
+    const claudeBin = resolveBinary('claude', config.HOME_DIR)
+    const allowedTools = [
+      'mcp__meeting__meeting_wait_for_next_message',
+      'mcp__meeting__meeting_speak',
+      'mcp__meeting__meeting_get_state',
+      'mcp__meeting__meeting_leave',
+    ].join(',')
+    const llmCommand = `${claudeBin} -p --mcp-config "${mcpConfigFile}" --allowedTools "${allowedTools}" < "${promptFile}"`
+
+    await fs.writeFile(
+      execScript,
+      `#!/bin/bash\nexport HQ_URL="${effectiveHqUrl}"\nexport API_TOKEN="${config.API_TOKEN}"\nexport MINION_MEETING_ID="${meetingId}"\n${llmCommand}\n`,
+      'utf-8',
+    )
+    await execAsync(`chmod +x "${execScript}"`)
+
+    await execAsync(`tmux new-session -d -s "${sessionName}" -x 200 -y 50`, {
+      cwd: config.HOME_DIR,
+    })
+    await execAsync(`tmux set-option -t "${sessionName}" remain-on-exit on`)
+
+    const logFile = path.join(
+      logManager.LOG_DIR || path.join(config.HOME_DIR, '.minion', 'logs'),
+      `meeting-${meetingId}.log`,
+    )
+    try {
+      await execAsync(`tmux pipe-pane -o -t "${sessionName}" "cat >> ${logFile}"`)
+    } catch (err) {
+      console.error(`[MeetingRunner] pipe-pane failed: ${err.message}`)
+    }
+
+    await execAsync(`tmux send-keys -t "${sessionName}" "bash ${execScript}" Enter`)
+
+    runningTasks.add({
+      type: 'meeting',
+      session_name: sessionName,
+      meeting_id: meetingId,
+      started_at: new Date().toISOString(),
+    })
+
+    console.log(`[MeetingRunner] Meeting ${meetingId} session started`)
+    return { sessionName, started: true, success: true }
+  } catch (err) {
+    console.error(`[MeetingRunner] Meeting ${meetingId} failed to start: ${err.message}`)
+    return { sessionName, started: false, success: false, error: err.message }
+  }
+}
+
+module.exports = {
+  runMeeting,
+  killMeetingSession,
+  listMeetingSessions,
+  generateSessionName,
+}

package/linux/server.js

@@ -23,6 +23,7 @@
  * TODOs:                GET/POST /api/todos, GET/PUT/DELETE /api/todos/:id
  * Emails:               POST /api/email/inbox, GET /api/email/inbox, GET/PUT/DELETE /api/email/inbox/:id
  * Sudoers:              GET /api/sudoers
+ * Meetings (exp):       POST /api/meetings/invitations, DELETE /api/meetings/:id, GET /api/meetings/active
  * ─────────────────────────────────────────────────────────────────────────────
  */
 
@@ -94,6 +95,8 @@ const { fileRoutes } = require('./routes/files')
 const { directiveRoutes } = require('./routes/directives')
 const { chatRoutes, runQuickLlmCall } = require('./routes/chat')
 const { configRoutes } = require('./routes/config')
+const { meetingRoutes } = require('../core/routes/meetings')
+const meetingRunner = require('./meeting-runner')
 
 // Validate configuration before starting
 validate()
@@ -308,6 +311,9 @@ async function registerAllRoutes(app) {
   await app.register(directiveRoutes)
   await app.register(chatRoutes)
   await app.register(configRoutes)
+
+  // Experimental: meetings (shared route + linux runner)
+  await app.register(meetingRoutes, { meetingRunner })
 }
 
 // Start server

package/package.json

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

package/rules/core.md

@@ -277,6 +277,38 @@ Routine 実行中は以下もtmuxセッション環境で利用可能:
 
 詳細な API 仕様は `~/.minion/docs/api-reference.md` の「Project Sprints」「Project Tasks」セクションを参照。
 
+## Meeting Participation (ミーティング参加, experimental, v3.59.0〜)
+
+HQ からミーティング招待 (`POST /api/meetings/invitations`) を受け取ると、専用 tmux セッション `mt-{meetingId8}` で claude が起動し、`meeting` MCP サーバー経由で会議に参加する。
+
+**基本ループ:**
+1. `meeting_get_state` で参加者・目的・タイトルを把握
+2. `meeting_wait_for_next_message` で次の発言を long-poll (最大 25秒)
+3. 受信メッセージを評価:
+   - 自分の役割・コンテキストに関連するか?
+   - 直前の発言で他者が同趣旨を発言していないか?
+   - 自分宛 (mention) か、自分が応答すべき話題か?
+4. 応答すべきなら `meeting_speak` で **1-3 文程度** の発言を送信
+5. 戻り値が `{ meeting_ended: true }` になったら `meeting_leave` を呼んで終了
+
+**振る舞いのルール:**
+- 発言は短く保つ (会議でだらだら話さない)
+- 他のミニオンの発言と重複しない (既に同じ趣旨を誰かが言っていたら追従しない)
+- 議論を前進させる発言を優先 (賛否・代替案・質問・確認)
+- 既存タスク・スプリント状態を踏まえて発言する
+- **PMロールで参加する場合は議事進行と成果物作成も担う**:
+  - 議論が発散したら論点を整理して提示
+  - ミーティング終了前に趣旨に応じた成果物を作成:
+    - スプリント計画 → `hq sprint create` + `hq task create` (連結)
+    - 振り返り → `hq note create`
+    - ブロッカー解決 → 関連スレッドを resolve + note作成
+  - 趣旨が曖昧な場合は終了前に「何を成果物として残すか」を参加者に確認
+  - 結論が出なかった話題は thread や project task に転記してフォロー
+
+セッション復帰機構はまだ未実装 (claude/tmux が落ちた場合は再起動しない)。
+
+API詳細は `~/.minion/docs/api-reference.md` の「Meeting Rooms」セクションを参照。
+
 ## Todo運用ルール
 
 チャット中のタスクは `/api/todos` に登録して進捗管理すること。圧縮（context compaction）を跨いでも作業を完遂するための仕組みがある。

package/win/meeting-runner.js

@@ -0,0 +1,165 @@
+/**
+ * Meeting Runner (Windows / WSL)
+ *
+ * Spawns a dedicated tmux session inside WSL per meeting invitation.
+ * Mirrors linux/meeting-runner.js but routes commands through WSL since
+ * Windows native tmux is not available.
+ *
+ * Session naming: `mt-{meetingId.slice(0,8)}`
+ */
+
+const { exec } = require('child_process')
+const { promisify } = require('util')
+const fs = require('fs').promises
+const os = require('os')
+const path = require('path')
+const execAsync = promisify(exec)
+
+const { config } = require('../core/config')
+const runningTasks = require('../core/lib/running-tasks')
+const logManager = require('../core/lib/log-manager')
+const { getActivePrimary } = require('../core/llm-plugins/lib/active')
+const { buildMeetingKickoffPrompt } = require('../core/meetings/meeting-prompt')
+
+function generateSessionName(meetingId) {
+  if (!meetingId) throw new Error('meetingId is required')
+  return `mt-${String(meetingId).substring(0, 8)}`
+}
+
+function wslExec(cmd) {
+  return execAsync(`wsl bash -lc ${JSON.stringify(cmd)}`)
+}
+
+async function tmuxHasSession(sessionName) {
+  try {
+    await wslExec(`tmux has-session -t "${sessionName}" 2>/dev/null`)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function listMeetingSessions() {
+  try {
+    const { stdout } = await wslExec(`tmux ls -F '#S' 2>/dev/null`)
+    return stdout
+      .split('\n')
+      .map((s) => s.trim())
+      .filter((s) => s.startsWith('mt-'))
+  } catch {
+    return []
+  }
+}
+
+async function killMeetingSession(meetingId) {
+  const sessionName = generateSessionName(meetingId)
+  try {
+    await wslExec(`tmux kill-session -t "${sessionName}" 2>/dev/null`)
+    runningTasks.remove(sessionName)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function runMeeting({ meetingId, title, purpose, host, hqUrl, selfName, role }) {
+  if (!meetingId) {
+    return { sessionName: null, started: false, success: false, error: 'meetingId is required' }
+  }
+
+  const sessionName = generateSessionName(meetingId)
+
+  if (await tmuxHasSession(sessionName)) {
+    console.log(`[MeetingRunner-win] tmux session ${sessionName} already exists, skipping start`)
+    return { sessionName, started: false, success: true }
+  }
+
+  const tmpdir = os.tmpdir()
+  const promptFile = path.join(tmpdir, `minion-meeting-prompt-${sessionName}.txt`)
+  const mcpConfigFile = path.join(tmpdir, `minion-meeting-mcp-${sessionName}.json`)
+  const execScript = path.join(tmpdir, `minion-meeting-exec-${sessionName}.sh`)
+  const mcpServerPath = path.join(__dirname, '..', 'core', 'meetings', 'meeting-mcp-server.js')
+
+  try {
+    await logManager.ensureLogDir()
+
+    const prompt = buildMeetingKickoffPrompt({
+      meetingId,
+      title,
+      purpose,
+      host,
+      selfName: selfName || 'minion',
+      role: role || null,
+    })
+    await fs.writeFile(promptFile, prompt, 'utf-8')
+
+    // Use the minion's own config.HQ_URL when available. HQ-pushed hq_url is
+    // only a fallback because the minion already has the correct URL set at
+    // provisioning time.
+    const effectiveHqUrl = config.HQ_URL || hqUrl
+    if (!effectiveHqUrl) {
+      throw new Error('No HQ_URL configured (neither minion config nor HQ push)')
+    }
+
+    const mcpConfig = {
+      mcpServers: {
+        meeting: {
+          command: 'node',
+          args: [mcpServerPath],
+          env: {
+            HQ_URL: effectiveHqUrl,
+            API_TOKEN: config.API_TOKEN,
+            MINION_MEETING_ID: meetingId,
+          },
+        },
+      },
+    }
+    await fs.writeFile(mcpConfigFile, JSON.stringify(mcpConfig, null, 2), 'utf-8')
+
+    const primary = getActivePrimary()
+    if (!primary || primary.name !== 'claude') {
+      throw new Error(
+        'Meeting participation currently requires the claude primary LLM (MCP support).',
+      )
+    }
+
+    // See linux/meeting-runner.js for why --allowedTools is needed (-p mode
+    // hangs on MCP permission prompts without this).
+    const allowedTools = [
+      'mcp__meeting__meeting_wait_for_next_message',
+      'mcp__meeting__meeting_speak',
+      'mcp__meeting__meeting_get_state',
+      'mcp__meeting__meeting_leave',
+    ].join(',')
+
+    await fs.writeFile(
+      execScript,
+      `#!/bin/bash\nexport HQ_URL="${effectiveHqUrl}"\nexport API_TOKEN="${config.API_TOKEN}"\nexport MINION_MEETING_ID="${meetingId}"\nclaude -p --mcp-config "${mcpConfigFile}" --allowedTools "${allowedTools}" < "${promptFile}"\n`,
+      'utf-8',
+    )
+
+    await wslExec(`chmod +x "${execScript}"`)
+    await wslExec(`tmux new-session -d -s "${sessionName}" -x 200 -y 50`)
+    await wslExec(`tmux set-option -t "${sessionName}" remain-on-exit on`)
+    await wslExec(`tmux send-keys -t "${sessionName}" "bash ${execScript}" Enter`)
+
+    runningTasks.add({
+      type: 'meeting',
+      session_name: sessionName,
+      meeting_id: meetingId,
+      started_at: new Date().toISOString(),
+    })
+
+    return { sessionName, started: true, success: true }
+  } catch (err) {
+    console.error(`[MeetingRunner-win] Failed to start meeting ${meetingId}: ${err.message}`)
+    return { sessionName, started: false, success: false, error: err.message }
+  }
+}
+
+module.exports = {
+  runMeeting,
+  killMeetingSession,
+  listMeetingSessions,
+  generateSessionName,
+}

package/win/server.js

@@ -49,6 +49,8 @@ const { fileRoutes } = require('./routes/files')
 const { directiveRoutes } = require('./routes/directives')
 const { chatRoutes, runQuickLlmCall } = require('./routes/chat')
 const { configRoutes } = require('./routes/config')
+const { meetingRoutes } = require('../core/routes/meetings')
+const meetingRunner = require('./meeting-runner')
 
 // Compatible route modules (reused from Linux)
 const { healthRoutes, setOffline } = require('../core/routes/health')
@@ -255,6 +257,9 @@ async function registerRoutes(app) {
   await app.register(directiveRoutes)
   await app.register(chatRoutes)
   await app.register(configRoutes)
+
+  // Experimental: meetings (shared route + windows runner)
+  await app.register(meetingRoutes, { meetingRunner })
 }
 
 // Start server