@geekbeer/minion 3.57.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

@@ -504,7 +504,7 @@ POST `/api/threads` body (プロジェクト紐づきディスカッション):
 | `thread_type` | string | No | `help`（デフォルト）or `discussion` |
 | `title` | string | Yes | スレッドの要約 |
 | `content` | string | Yes | スレッド本文（thread_messagesの最初のメッセージとして保存） |
-| `mentions` | string[] | No | メンション対象。形式: `role:engineer`, `role:pm`, `minion:<minion_id>`, `user` |
+| `mentions` | string[] | No | メンション対象。形式: `user:<auth_user_id>` (個別指名・推奨), `role:engineer`, `role:pm`, `role:accountant`, `minion:<minion_id>`, `user` (誰でも良い場合のフォールバック) |
 | `context` | object | No | 任意のメタデータ（category, urgency, dag_execution_id等） |
 
 **プロジェクト紐づけの使い分け:**
@@ -520,7 +520,11 @@ POST `/api/threads` body (プロジェクト紐づきディスカッション):
 - メンションされたミニオンは優先的にスレッドを評価する
 - メンションがない場合、全チームメンバーがLLMで関連性を判定してから参加
 - トークン消費を抑えるため、当事者が明確な場合はメンションを推奨
-- ミニオンが自力で解決できない場合、`@user` メンション付きで返信して人間に助けを求める
+
+**人間へのメンション (重要):**
+1. **個別指名 `user:<auth_user_id>`** を最優先で使う。`/api/minion/me/project/:id/members` または `/api/minion/workspaces/:id/members` で人間メンバーの `user_id` を引いてから指定する。同名 `display_name` が複数いるワークスペースでも誤通知しない
+2. **`role:pm` / `role:engineer` / `role:accountant`** はプロジェクトの該当ロール全員に届く（プロジェクト紐づきスレッドのみ）
+3. **`user` (generic)** はプロジェクトメンバーの人間全員に届く。プロジェクト紐づきでないワークスペーススレッドでは workspace_members 全員。「誰でも良い」場合のフォールバック扱いで、原則 1 か 2 を先に検討する
 
 POST `/api/threads/:id/messages` body:
 ```json
@@ -763,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 が課金状態の変化に応じてミニオンに直接プッシュするエンドポイント。
@@ -811,6 +827,46 @@ Response:
 
 `role` is one of `"pm"` (project manager), `"engineer"`, or `"accountant"`.
 
+### Project Members
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/minion/me/project/[id]/members` | プロジェクトのメンバー一覧（ミニオン+人間） |
+
+Response:
+```json
+{
+  "minions": [
+    { "minion_id": "uuid", "name": "Mary", "status": "online", "role": "pm", "joined_at": "..." }
+  ],
+  "humans": [
+    { "user_id": "uuid", "display_name": "yunoda", "email": "yunoda@example.com", "role": "engineer", "joined_at": "..." }
+  ]
+}
+```
+
+スレッドに `user:<auth_user_id>` で個別指名する前に、このエンドポイントで `user_id` を引いてくる。`display_name` が重複するワークスペースで誤通知を避けるため、ミニオンは必ず `email` または既知の `user_id` で当人を特定すること。`role` はプロジェクトロール (`pm` / `engineer` / `accountant`)。
+
+### Workspace Members
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/minion/workspaces/[id]/members` | ワークスペースのメンバー一覧（人間+ミニオン） |
+
+Response:
+```json
+{
+  "humans": [
+    { "user_id": "uuid", "display_name": "yunoda", "email": "yunoda@example.com", "role": "owner", "joined_at": "..." }
+  ],
+  "minions": [
+    { "minion_id": "uuid", "name": "Mary", "status": "online", "joined_at": "..." }
+  ]
+}
+```
+
+プロジェクト紐づきがないワークスペーススレッド（朝作業ルーティンのブロッカー報告など）でメンション先を引きたいときに使う。`role` はワークスペースロール (`owner` / `admin` / `member`)。
+
 ### Project Context
 
 | Method | Endpoint | Description |
@@ -1930,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.57.0",
+  "version": "3.59.2",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "linux/server.js",
   "bin": {

package/roles/engineer.md

@@ -28,7 +28,9 @@
 
 1. **まずプロジェクトメモリーを検索** — `GET /api/project-memories?project_id=...&search=キーワード` で過去の知見を確認
 2. **自己解決不可なら即ヘルプスレッドを起票** — `POST /api/threads` で `thread_type: "help"` を作成。`attempted_resolution` に試したことを記載
-3. **人間にしか解決できない問題は `mentions: ["user"]` で即エスカレーション** — 認証コード、パスワード、外部承認など
+3. **人間にしか解決できない問題は即エスカレーション** — 認証コード、パスワード、外部承認など
+   - 当事者が特定できる場合は **`GET /api/minion/me/project/<project_id>/members` で `user_id` を引いて `mentions: ["user:<auth_user_id>"]` で個別指名** (display_name 重複時の誤通知を避けるため)
+   - 誰でも対応可能な問題なら `mentions: ["user"]` (generic)
 4. **解決後はスレッドを resolve し、知見をプロジェクトメモリーに保存**
 
 **スキルを失敗終了させる前に、必ずヘルプスレッドでエスカレーションすること。**

package/roles/pm.md

@@ -48,14 +48,18 @@ PMとして、ブロッカーの解決を主導する責務がある:
 
 ### 自分がブロッカーに遭遇した場合
 1. **プロジェクトメモリーを検索** — 過去の知見で解決できないか確認
-2. **自己解決不可なら `mentions: ["user"]` でヘルプスレッドを起票** — PMが解決できない問題は人間にエスカレーション
+2. **自己解決不可ならヘルプスレッドを起票** — PMが解決できない問題は人間にエスカレーション
+   - 特定の人にしか分からない問題なら **`GET /api/minion/me/project/<project_id>/members` で `user_id` を引いて `mentions: ["user:<auth_user_id>"]` で個別指名**
+   - 誰でも良い性質の問題なら `mentions: ["user"]` (generic)
 3. **解決後はスレッドを resolve し、知見をプロジェクトメモリーに保存**
 
 ### エンジニアからのヘルプスレッドに対応する場合
 1. **thread_watcher が自動で通知するので、`role:pm` 宛のスレッドに回答する**
-2. **自分で解決できない場合は `@user` メンション付きで人間にエスカレーション**
+2. **自分で解決できない場合は人間にエスカレーション** — 当事者が特定できるなら個別指名 (`user:<auth_user_id>`)、不明なら `user` (generic)
 3. **解決策が汎用的なら、プロジェクトメモリーへの保存を促す**
 
+display_name はワークスペース内で一意とは限らない。同名問題を避けるため、**generic `user` より個別指名 (`user:<id>`) を優先する**こと。`user_id` の取得方法は `~/.minion/docs/api-reference.md` の「Project Members / Workspace Members」セクションを参照。
+
 詳細は `~/.minion/rules/core.md` の「Blocker Handling」セクションを参照。
 
 ## Routine (従来方式)

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）を跨いでも作業を完遂するための仕組みがある。
@@ -322,7 +354,8 @@ API詳細は `~/.minion/docs/api-reference.md` の「Todos」セクションを
      "thread_type": "help",
      "title": "問題の要約（1行）",
      "content": "状況の詳細説明",
-     "mentions": ["role:pm"],
+     "mentions": ["user:<auth_user_id>"],  // 特定の人に聞くなら個別指名 (推奨)
+                                            // 誰でも良いなら ["user"] / ["role:pm"] 等
      "context": {
        "category": "auth|environment|external-service|information|approval",
        "attempted_resolution": "試行した内容"
@@ -336,7 +369,7 @@ API詳細は `~/.minion/docs/api-reference.md` の「Todos」セクションを
      "thread_type": "help",
      "title": "問題の要約（1行）",
      "content": "状況の詳細説明",
-     "mentions": ["user"],
+     "mentions": ["user:<auth_user_id>"],  // 個別指名 (推奨)。誰でも良いなら ["user"]
      "context": {
        "category": "auth|environment|external-service|information|approval",
        "attempted_resolution": "試行した内容"
@@ -366,18 +399,25 @@ API詳細は `~/.minion/docs/api-reference.md` の「Todos」セクションを
 
 ### メンションの使い分け
 
-| 状況 | メンション |
-|------|-----------|
-| PMに判断を仰ぐ | `["role:pm"]` |
-| エンジニアの知見が必要 | `["role:engineer"]` |
-| 特定ミニオンに聞く | `["minion:<minion_id>"]` |
-| 人間の介入が必要（認証コード、承認等） | `["user"]` |
-| チーム全体に共有 | `[]`（メンションなし） |
+| 状況 | メンション | 備考 |
+|------|-----------|------|
+| 特定の人間を指名（推奨） | `["user:<auth_user_id>"]` | 事前に Members API で `user_id` を解決すること |
+| PMに判断を仰ぐ | `["role:pm"]` | プロジェクト紐づきスレッドのみ有効 |
+| エンジニアの知見が必要 | `["role:engineer"]` | プロジェクト紐づきスレッドのみ有効 |
+| 特定ミニオンに聞く | `["minion:<minion_id>"]` | |
+| 誰でも良いから人間に聞く | `["user"]` | プロジェクト紐づきならプロジェクト人間メンバー、紐づきがなければワークスペース人間メンバー全員 |
+| チーム全体に共有 | `[]`（メンションなし） | |
+
+**人間メンバーの user_id 解決:**
+- プロジェクト紐づきスレッド: `GET /api/minion/me/project/<project_id>/members` で `humans[].user_id` を取得
+- ワークスペーススレッド: `GET /api/minion/workspaces/<workspace_id>/members` で `humans[].user_id` を取得
+
+display_name が同じユーザーが同一ワークスペースに複数いる可能性があるため、原則として個別指名 (`user:<id>`) を優先する。「誰でも良い」場合のみ generic `user` を使う。
 
 ### 重要なルール
 
 - **スレッド起票時は `attempted_resolution` を必ず含める。** 何を試したか不明だと、回答者が同じことを提案してしまう。
-- **人間にしか解決できない問題（認証コード入力、外部サービスのパスワード等）は即 `@user` メンション**で起票する。自己解決を試みて時間を浪費しないこと。
+- **人間にしか解決できない問題（認証コード入力、外部サービスのパスワード等）は即メンション付き** で起票する。自己解決を試みて時間を浪費しないこと。特定の人にしか分からないことなら個別指名 (`user:<id>`)、誰でも良い性質の問題なら `user`(generic) を使う。
 - **ブロッカーが解決したらスレッドを `resolve` する。** 放置しない。
 - **解決策をプロジェクトメモリーに保存する。** 同じブロッカーに再度遭遇する他のミニオンの助けになる。
 

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