@geekbeer/minion 3.11.5 → 3.14.0

package/core/db.js

@@ -195,6 +195,7 @@ function initSchema(db) {
     -- ==================== chat_sessions ====================
     CREATE TABLE IF NOT EXISTS chat_sessions (
       session_id TEXT PRIMARY KEY,
+      workspace_id TEXT,
       turn_count INTEGER NOT NULL DEFAULT 0,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
@@ -390,57 +391,87 @@ function migrateSchema(db) {
   }
 
   if (currentVersion < 2) {
-    console.log('[DB] Migration 2: Adding emails FTS5...')
-
-    db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS emails_fts USING fts5(
-        subject,
-        body_text,
-        content=emails,
-        content_rowid=rowid,
-        tokenize='trigram'
-      );
-
-      CREATE TRIGGER IF NOT EXISTS emails_ai AFTER INSERT ON emails BEGIN
-        INSERT INTO emails_fts(rowid, subject, body_text)
-          VALUES (new.rowid, new.subject, new.body_text);
-      END;
+    try {
+      console.log('[DB] Migration 2: Adding emails FTS5...')
+
+      db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS emails_fts USING fts5(
+          subject,
+          body_text,
+          content=emails,
+          content_rowid=rowid,
+          tokenize='trigram'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS emails_ai AFTER INSERT ON emails BEGIN
+          INSERT INTO emails_fts(rowid, subject, body_text)
+            VALUES (new.rowid, new.subject, new.body_text);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS emails_ad AFTER DELETE ON emails BEGIN
+          INSERT INTO emails_fts(emails_fts, rowid, subject, body_text)
+            VALUES ('delete', old.rowid, old.subject, old.body_text);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS emails_au AFTER UPDATE ON emails BEGIN
+          INSERT INTO emails_fts(emails_fts, rowid, subject, body_text)
+            VALUES ('delete', old.rowid, old.subject, old.body_text);
+          INSERT INTO emails_fts(rowid, subject, body_text)
+            VALUES (new.rowid, new.subject, new.body_text);
+        END;
+
+        INSERT INTO emails_fts(emails_fts) VALUES ('rebuild');
+
+        INSERT INTO schema_version (version) VALUES (2);
+      `)
+
+      console.log('[DB] Migration 2 complete: emails FTS5 added')
+    } catch (err) {
+      console.warn(`[DB] Migration 2 skipped (emails table may not exist yet): ${err.message}`)
+      // Mark as applied so it doesn't block subsequent migrations.
+      // emails FTS will be created by initSchema on next fresh DB.
+      try { db.exec("INSERT OR IGNORE INTO schema_version (version) VALUES (2)") } catch {}
+    }
+  }
 
-      CREATE TRIGGER IF NOT EXISTS emails_ad AFTER DELETE ON emails BEGIN
-        INSERT INTO emails_fts(emails_fts, rowid, subject, body_text)
-          VALUES ('delete', old.rowid, old.subject, old.body_text);
-      END;
+  if (currentVersion < 3) {
+    try {
+      console.log('[DB] Migration 3: Adding project_id to memories...')
 
-      CREATE TRIGGER IF NOT EXISTS emails_au AFTER UPDATE ON emails BEGIN
-        INSERT INTO emails_fts(emails_fts, rowid, subject, body_text)
-          VALUES ('delete', old.rowid, old.subject, old.body_text);
-        INSERT INTO emails_fts(rowid, subject, body_text)
-          VALUES (new.rowid, new.subject, new.body_text);
-      END;
+      db.exec(`
+        ALTER TABLE memories ADD COLUMN project_id TEXT DEFAULT NULL;
 
-      INSERT INTO emails_fts(emails_fts) VALUES ('rebuild');
+        CREATE INDEX IF NOT EXISTS idx_memories_project_id ON memories(project_id);
 
-      INSERT INTO schema_version (version) VALUES (2);
-    `)
+        INSERT INTO schema_version (version) VALUES (3);
+      `)
 
-    console.log('[DB] Migration 2 complete: emails FTS5 added')
+      console.log('[DB] Migration 3 complete: memories.project_id added')
+    } catch (err) {
+      // Column may already exist (duplicate column error)
+      console.warn(`[DB] Migration 3 skipped: ${err.message}`)
+      try { db.exec("INSERT OR IGNORE INTO schema_version (version) VALUES (3)") } catch {}
+    }
   }
 
-  if (currentVersion < 3) {
-    console.log('[DB] Migration 3: Adding project_id to memories...')
+  if (currentVersion < 4) {
+    try {
+      console.log('[DB] Migration 4: Adding workspace_id to chat_sessions...')
 
-    db.exec(`
-      -- Add nullable project_id column to memories table.
-      -- NULL = universal memory (cross-project knowledge).
-      -- Set = project-scoped memory.
-      ALTER TABLE memories ADD COLUMN project_id TEXT DEFAULT NULL;
+      db.exec(`
+        ALTER TABLE chat_sessions ADD COLUMN workspace_id TEXT DEFAULT NULL;
 
-      CREATE INDEX idx_memories_project_id ON memories(project_id);
+        CREATE INDEX IF NOT EXISTS idx_chat_sessions_workspace
+          ON chat_sessions(workspace_id, updated_at DESC);
 
-      INSERT INTO schema_version (version) VALUES (3);
-    `)
+        INSERT INTO schema_version (version) VALUES (4);
+      `)
 
-    console.log('[DB] Migration 3 complete: memories.project_id added')
+      console.log('[DB] Migration 4 complete: chat_sessions.workspace_id added')
+    } catch (err) {
+      console.warn(`[DB] Migration 4 skipped: ${err.message}`)
+      try { db.exec("INSERT OR IGNORE INTO schema_version (version) VALUES (4)") } catch {}
+    }
   }
 }
 

package/core/stores/chat-store.js

@@ -1,7 +1,7 @@
 /**
  * Chat Session Store (SQLite)
  * Persists chat sessions and messages.
- * Supports multiple sessions: one active + archived past sessions.
+ * Supports multiple sessions scoped by workspace_id.
  * Claude CLI manages conversation context via --resume.
  */
 
@@ -10,14 +10,22 @@ const { getDb } = require('../db')
 const MAX_MESSAGES = 100
 
 /**
- * Load the active (most recent) chat session
+ * Load the active (most recent) chat session for a workspace.
+ * @param {string|null} workspaceId - Workspace ID to scope sessions
  * @returns {object|null} Session object or null if none exists
  */
-function load() {
+function load(workspaceId) {
   const db = getDb()
-  const session = db.prepare(
-    'SELECT * FROM chat_sessions ORDER BY updated_at DESC LIMIT 1'
-  ).get()
+  let session
+  if (workspaceId) {
+    session = db.prepare(
+      'SELECT * FROM chat_sessions WHERE workspace_id = ? ORDER BY updated_at DESC LIMIT 1'
+    ).get(workspaceId)
+  } else {
+    session = db.prepare(
+      'SELECT * FROM chat_sessions WHERE workspace_id IS NULL ORDER BY updated_at DESC LIMIT 1'
+    ).get()
+  }
   if (!session) return null
 
   const messages = db.prepare(
@@ -26,6 +34,7 @@ function load() {
 
   return {
     session_id: session.session_id,
+    workspace_id: session.workspace_id,
     messages,
     turn_count: session.turn_count,
     created_at: session.created_at,
@@ -49,6 +58,7 @@ function loadById(sessionId) {
 
   return {
     session_id: session.session_id,
+    workspace_id: session.workspace_id,
     messages,
     turn_count: session.turn_count,
     created_at: session.created_at,
@@ -57,15 +67,32 @@ function loadById(sessionId) {
 }
 
 /**
- * List all sessions (metadata only, no messages)
+ * List sessions, optionally filtered by workspace_id.
  * @param {number} limit
- * @returns {Array<{ session_id, turn_count, message_count, created_at, updated_at }>}
+ * @param {string|null} workspaceId - If provided, filter by workspace
+ * @returns {Array<{ session_id, workspace_id, turn_count, message_count, created_at, updated_at }>}
  */
-function listSessions(limit = 50) {
+function listSessions(limit = 50, workspaceId) {
   const db = getDb()
+  if (workspaceId) {
+    return db.prepare(`
+      SELECT
+        s.session_id,
+        s.workspace_id,
+        s.turn_count,
+        s.created_at,
+        s.updated_at,
+        (SELECT COUNT(*) FROM chat_messages WHERE session_id = s.session_id) as message_count
+      FROM chat_sessions s
+      WHERE s.workspace_id = ?
+      ORDER BY s.updated_at DESC
+      LIMIT ?
+    `).all(workspaceId, limit)
+  }
   return db.prepare(`
     SELECT
       s.session_id,
+      s.workspace_id,
       s.turn_count,
       s.created_at,
       s.updated_at,
@@ -88,8 +115,8 @@ function save(session) {
 
     // Insert session
     db.prepare(
-      'INSERT INTO chat_sessions (session_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?)'
-    ).run(session.session_id, session.turn_count || 0, session.created_at, session.updated_at)
+      'INSERT INTO chat_sessions (session_id, workspace_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?)'
+    ).run(session.session_id, session.workspace_id || null, session.turn_count || 0, session.created_at, session.updated_at)
 
     // Insert messages
     const insertMsg = db.prepare(
@@ -103,14 +130,15 @@ function save(session) {
 }
 
 /**
- * Add a message to the active session.
- * Creates a new session if none exists or session_id changed.
+ * Add a message to a session.
+ * Creates a new session if none exists for the given session_id.
  * Past sessions are preserved (not deleted).
  * @param {string} sessionId - Claude CLI session ID
  * @param {{ role: string, content: string }} msg - Message to add
  * @param {number} [turnCount] - Optional turn count to add
+ * @param {string|null} [workspaceId] - Workspace ID for new sessions
  */
-function addMessage(sessionId, msg, turnCount) {
+function addMessage(sessionId, msg, turnCount, workspaceId) {
   const db = getDb()
   const existing = db.prepare('SELECT * FROM chat_sessions WHERE session_id = ?').get(sessionId)
 
@@ -118,8 +146,8 @@ function addMessage(sessionId, msg, turnCount) {
   if (!existing) {
     const now = Date.now()
     db.prepare(
-      'INSERT INTO chat_sessions (session_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?)'
-    ).run(sessionId, 0, now, now)
+      'INSERT INTO chat_sessions (session_id, workspace_id, turn_count, created_at, updated_at) VALUES (?, ?, ?, ?, ?)'
+    ).run(sessionId, workspaceId || null, 0, now, now)
   }
 
   // Insert message
@@ -149,13 +177,21 @@ function addMessage(sessionId, msg, turnCount) {
 }
 
 /**
- * Clear the active session (remove from DB).
- * This deletes only the most recent session.
- * For reset flows, use clearActive() which preserves the session in history.
+ * Clear the active session for a workspace.
+ * @param {string|null} workspaceId - Workspace to clear session for
  */
-function clear() {
+function clear(workspaceId) {
   const db = getDb()
-  const active = db.prepare('SELECT session_id FROM chat_sessions ORDER BY updated_at DESC LIMIT 1').get()
+  let active
+  if (workspaceId) {
+    active = db.prepare(
+      'SELECT session_id FROM chat_sessions WHERE workspace_id = ? ORDER BY updated_at DESC LIMIT 1'
+    ).get(workspaceId)
+  } else {
+    active = db.prepare(
+      'SELECT session_id FROM chat_sessions WHERE workspace_id IS NULL ORDER BY updated_at DESC LIMIT 1'
+    ).get()
+  }
   if (active) {
     db.prepare('DELETE FROM chat_sessions WHERE session_id = ?').run(active.session_id)
   }

package/docs/api-reference.md

@@ -54,9 +54,9 @@ Outcome values: `success`, `failure`, `partial`
 
 | Method | Endpoint | Description |
 |--------|----------|-------------|
-| GET | `/api/terminal/sessions` | List tmux sessions |
+| GET | `/api/terminal/sessions` | List sessions (CMD + WSL merged) |
 | POST | `/api/terminal/send` | Send keys. Body: `{session, input?, enter?, special?}` |
-| POST | `/api/terminal/create` | Create session. Body: `{name?, command?}` |
+| POST | `/api/terminal/create` | Create session. Body: `{name?, command?, type?, get_or_create?}` |
 | POST | `/api/terminal/kill` | Kill session. Body: `{session}` |
 | GET | `/api/terminal/capture` | Capture pane content. Query: `?session=&lines=100` |
 | GET | `/api/terminal/ttyd/status` | ttyd process status |
@@ -64,6 +64,31 @@ Outcome values: `success`, `failure`, `partial`
 | POST | `/api/terminal/ttyd/stop` | Stop ttyd for session. Body: `{session}` |
 | POST | `/api/terminal/ttyd/stop-all` | Stop all ttyd processes |
 
+#### WSL セッション（Windows ミニオン限定）
+
+WSL 内でコマンドを実行するには `type: "wsl"` を指定する。セッション名は `wsl-` prefix が自動付与される。
+
+```bash
+# WSL セッション作成（既存があれば再利用）
+curl -X POST http://localhost:8080/api/terminal/create \
+  -H "Authorization: Bearer $API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "wsl-dev", "type": "wsl", "get_or_create": true}'
+```
+
+| パラメータ | 型 | 説明 |
+|-----------|-----|------|
+| `type` | string | `"wsl"` で WSL セッションを作成 |
+| `get_or_create` | boolean | `true` の場合、同名の既存セッションがあれば再利用（レスポンスに `reused: true`） |
+
+WSL セッションの上限は **5つ**。上限に達すると `429` を返す。不要なセッションを `kill` してから再作成すること。
+
+```bash
+# WSL サーバー稼働状態の確認
+curl http://localhost:8080/api/terminal/wsl/status \
+  -H "Authorization: Bearer $API_TOKEN"
+```
+
 ### Files
 
 Files are stored in `~/files/`. Max upload size: 50MB.

package/docs/environment-setup.md

@@ -232,6 +232,14 @@ curl -X POST http://localhost:8080/api/chat \
 | 7682 | WSL session server (HTTP API) | localhost のみ |
 | 7683 | WSL session server (WebSocket) | localhost のみ、ttyd プロトコル |
 
+### セッション管理
+
+- **セッション再利用**: `get_or_create: true` を指定すると、同名の既存セッションがあれば再利用される。毎回新しいセッションを作らないこと。
+- **固定名**: `wsl-dev`, `wsl-build` など目的を示す名前を使う。名前を省略するとタイムスタンプ名が生成され再利用できない。
+- **上限**: WSL セッションは最大 5 つ。上限に達すると作成が拒否される。
+- **自動クリーンアップ**: 完了済みセッションは 5 分後に自動削除される。
+- **手動クリーンアップ**: 不要なセッションは `POST /api/terminal/kill` で終了する。
+
 ### トラブルシューティング
 
 | 問題 | 原因 | 対処 |
@@ -239,6 +247,7 @@ curl -X POST http://localhost:8080/api/chat \
 | WSL session server is not running | ユーザーが未ログイン | RDP/コンソールでログイン |
 | WSL not detected during setup | WSL 未インストール | `wsl --install` を実行後 `minion-cli setup` を再実行 |
 | Connection refused on port 7682 | サーバー異常終了 | `schtasks /Run /TN "MinionWSL"` で再起動 |
+| WSL session limit reached | 5 セッション上限 | `GET /api/terminal/sessions` で確認し不要なセッションを `kill` |
 
 ---
 

package/linux/routes/chat.js

@@ -41,20 +41,22 @@ async function chatRoutes(fastify) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { message, session_id, context } = request.body || {}
+    const { message, session_id, context, workspace_id } = request.body || {}
 
     if (!message || typeof message !== 'string') {
       reply.code(400)
       return { success: false, error: 'message is required' }
     }
 
+    const workspaceId = workspace_id || null
+
     // Build prompt — add memory context on new sessions + page context
     const prompt = await buildContextPrefix(message, context, session_id)
 
     // Store user message
     const currentSessionId = session_id || null
     if (currentSessionId) {
-      await chatStore.addMessage(currentSessionId, { role: 'user', content: message })
+      await chatStore.addMessage(currentSessionId, { role: 'user', content: message }, undefined, workspaceId)
     }
 
     // Take over response handling from Fastify for SSE streaming
@@ -68,7 +70,7 @@ async function chatRoutes(fastify) {
     reply.raw.flushHeaders()
 
     try {
-      await streamLlmResponse(reply.raw, prompt, currentSessionId)
+      await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message)
     } catch (err) {
       console.error('[Chat] stream error:', err.message)
       const errorEvent = JSON.stringify({ type: 'error', error: err.message })
@@ -78,14 +80,15 @@ async function chatRoutes(fastify) {
     reply.raw.end()
   })
 
-  // GET /api/chat/session - Get active chat session
+  // GET /api/chat/session - Get active chat session for a workspace
   fastify.get('/api/chat/session', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
-    const session = chatStore.load()
+    const workspaceId = request.query?.workspace_id || null
+    const session = chatStore.load(workspaceId)
     if (!session) {
       return { success: true, session: null }
     }
@@ -94,6 +97,7 @@ async function chatRoutes(fastify) {
       success: true,
       session: {
         session_id: session.session_id,
+        workspace_id: session.workspace_id,
         messages: session.messages,
         turn_count: session.turn_count,
         created_at: session.created_at,
@@ -102,7 +106,7 @@ async function chatRoutes(fastify) {
     }
   })
 
-  // GET /api/chat/sessions - List all sessions (metadata only)
+  // GET /api/chat/sessions - List sessions, optionally filtered by workspace
   fastify.get('/api/chat/sessions', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
@@ -110,7 +114,8 @@ async function chatRoutes(fastify) {
     }
 
     const limit = parseInt(request.query?.limit) || 50
-    const sessions = chatStore.listSessions(limit)
+    const workspaceId = request.query?.workspace_id || undefined
+    const sessions = chatStore.listSessions(limit, workspaceId)
     return { success: true, sessions }
   })
 
@@ -130,14 +135,15 @@ async function chatRoutes(fastify) {
     return { success: true, session }
   })
 
-  // POST /api/chat/clear - Clear the active session
+  // POST /api/chat/clear - Clear the active session for a workspace
   fastify.post('/api/chat/clear', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
-    await chatStore.clear()
+    const workspaceId = request.body?.workspace_id || null
+    await chatStore.clear(workspaceId)
     return { success: true }
   })
 
@@ -168,42 +174,57 @@ async function chatRoutes(fastify) {
     return { success: true }
   })
 
-  // POST /api/chat/reset - Summarize conversation and start fresh session
+  // POST /api/chat/reset - Carry over relevant messages and start fresh session
   fastify.post('/api/chat/reset', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
-    const session = await chatStore.load()
+    const workspaceId = request.body?.workspace_id || null
+    const session = await chatStore.load(workspaceId)
     if (!session || session.messages.length === 0) {
-      await chatStore.clear()
-      return { success: true, summary: null }
+      await chatStore.clear(workspaceId)
+      return { success: true, carry_over: null }
     }
 
-    // Build summarization prompt from recent messages
+    // Take recent messages for topic analysis
     const recentMessages = session.messages.slice(-20)
-    const conversationText = recentMessages
-      .map(m => `${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content.substring(0, 500)}`)
-      .join('\n\n')
-
-    const summarizePrompt = `以下の会話を要約してください。重要なコンテキスト、決定事項、進行中のタスクを含めてください。200文字以内で。\n\n${conversationText}`
+    let carryOverMessages = recentMessages
 
-    let summary = null
+    // Ask LLM to find where the current topic begins
     try {
-      summary = await runQuickLlmCall(summarizePrompt)
-    } catch (err) {
-      console.error('[Chat] summarization failed:', err.message)
-      // Fallback: use last few messages as summary
-      const fallback = recentMessages.slice(-4)
-        .map(m => `${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content.substring(0, 200)}`)
+      const indexed = recentMessages
+        .map((m, i) => `[${i}] ${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content.substring(0, 300)}`)
         .join('\n')
-      summary = fallback
+
+      const analyzePrompt = `以下の会話履歴を分析し、現在進行中のトピックが始まったインデックス番号を特定してください。
+会話の流れが明確に変わったポイント（新しい質問・別の作業への切り替え等）がある場合、最後の切り替え以降のインデックスを返してください。
+全体が同じトピックの場合は 0 を返してください。
+
+数値のみを返してください（例: 5）。
+
+${indexed}`
+
+      const result = await runQuickLlmCall(analyzePrompt)
+      const breakIndex = parseInt(result.trim(), 10)
+      if (!isNaN(breakIndex) && breakIndex >= 0 && breakIndex < recentMessages.length) {
+        carryOverMessages = recentMessages.slice(breakIndex)
+        console.log(`[Chat] topic break at index ${breakIndex}, carrying over ${carryOverMessages.length}/${recentMessages.length} messages`)
+      }
+    } catch (err) {
+      console.error('[Chat] topic analysis failed, carrying over last 10:', err.message)
+      carryOverMessages = recentMessages.slice(-10)
     }
 
-    await chatStore.clear()
-    console.log(`[Chat] session reset with summary (${summary?.length || 0} chars)`)
-    return { success: true, summary }
+    // Format carry-over as conversation text
+    const carryOver = carryOverMessages
+      .map(m => `${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content}`)
+      .join('\n\n')
+
+    await chatStore.clear(workspaceId)
+    console.log(`[Chat] session reset, carrying over ${carryOverMessages.length} messages (${carryOver.length} chars)`)
+    return { success: true, carry_over: carryOver }
   })
 
   // POST /api/chat/end-of-day - Generate daily log + extract memories
@@ -341,7 +362,7 @@ function getLlmBinary() {
  * Tracks block types to correctly forward tool_use vs text events
  * and counts turns for session management.
  */
-function streamLlmResponse(res, prompt, sessionId) {
+function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage) {
   return new Promise((resolve, reject) => {
     const binaryName = getLlmBinary()
     if (!binaryName) {
@@ -516,11 +537,11 @@ function streamLlmResponse(res, prompt, sessionId) {
       if (resolvedSessionId) {
         // If this was a new session, also store the user message now
         if (!sessionId) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'user', content: prompt })
+          await chatStore.addMessage(resolvedSessionId, { role: 'user', content: originalMessage || prompt }, undefined, workspaceId)
         }
         // Store assistant response with turn count
         if (fullResponse) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount)
+          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
         }
       }
 
@@ -533,7 +554,7 @@ function streamLlmResponse(res, prompt, sessionId) {
       }
 
       // Load current turn count from session for the done event
-      const session = await chatStore.load()
+      const session = await chatStore.load(workspaceId)
       const totalTurnCount = session?.turn_count || turnCount
 
       const doneEvent = JSON.stringify({

package/package.json

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

package/rules/core.md

@@ -40,6 +40,30 @@ Minion
 
 API の詳細仕様は `~/.minion/docs/api-reference.md` の「Email」セクションを参照。
 
+## Terminal Session Management
+
+ターミナルセッション（`/api/terminal/*`）を使用する際は以下のルールに従うこと。
+
+### セッション再利用の原則
+
+- **新しいセッションを作る前に、既存セッションを確認する。**
+  ```bash
+  curl -H "Authorization: Bearer $API_TOKEN" http://localhost:8080/api/terminal/sessions
+  ```
+- 目的に合う既存セッション（未完了で再利用可能なもの）があれば、そのセッションに `send` でコマンドを送る。
+- 新規作成が必要な場合は、**目的を示す固定名**を付ける（例: `dev`, `build`, `test`）。タイムスタンプ名（`session-1234567890`）は避ける。
+
+### クリーンアップ
+
+- 作業が完了したセッションは `POST /api/terminal/kill` で終了する。
+- 一時的なコマンド実行（`command` 引数付きで作成したセッション）は、完了確認後に必ず kill する。
+- セッションを放置しない。使い終わったら片付ける。
+
+### セッション数の制限
+
+- 同時に保持するセッションは **最大3つ** を目安にする。
+- それ以上必要な場合は、不要なセッションを先に kill してから作成する。
+
 ## Available Tools
 
 ### CLI

package/rules/windows.md

@@ -0,0 +1,72 @@
+# Windows Minion
+
+Windows ミニオン固有のルール。
+
+## WSL セッション管理
+
+Windows ミニオンでは WSL（Windows Subsystem for Linux）内の Docker やリポジトリ操作のために WSL セッションを使用できる。
+
+### WSL セッションの使い方
+
+#### ターミナルセッション
+
+WSL 内でコマンドを実行するには `type: "wsl"` を指定してセッションを作成する:
+
+```bash
+# WSL セッション作成（固定名を付けること）
+curl -X POST http://localhost:8080/api/terminal/create \
+  -H "Authorization: Bearer $API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "wsl-dev", "type": "wsl"}'
+
+# コマンド送信
+curl -X POST http://localhost:8080/api/terminal/send \
+  -H "Authorization: Bearer $API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"session": "wsl-dev", "input": "docker compose up -d", "enter": true}'
+
+# 出力確認
+curl "http://localhost:8080/api/terminal/capture?session=wsl-dev&lines=50" \
+  -H "Authorization: Bearer $API_TOKEN"
+```
+
+#### チャット（WSL モード）
+
+チャット API に `wsl_mode: true` を追加すると、Claude Code CLI がユーザーセッションで実行され WSL コマンドを直接使用できる:
+
+```bash
+curl -X POST http://localhost:8080/api/chat \
+  -H "Authorization: Bearer $API_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"message": "WSL内でリポジトリをクローンしてDockerを起動して", "wsl_mode": true}'
+```
+
+### セッション管理ルール
+
+#### 再利用を徹底する
+
+- **WSL セッションの新規作成前に、必ず既存セッションを確認する。**
+  ```bash
+  curl -H "Authorization: Bearer $API_TOKEN" http://localhost:8080/api/terminal/sessions
+  ```
+  レスポンスの `type: "wsl"` かつ `completed: false` のセッションがあれば再利用する。
+- **固定名を使う。** `wsl-dev`, `wsl-build`, `wsl-docker` など目的を示す名前を付ける。
+  名前を省略すると `wsl-session-{timestamp}` が自動生成され、再利用できなくなる。
+- **1つの WSL セッションで複数コマンドを順次実行する。** コマンドごとに新しいセッションを作らない。
+
+#### クリーンアップ
+
+- WSL 作業が完了したら `POST /api/terminal/kill` でセッションを終了する。
+- WSL セッションは最大 **5つ** まで。上限に達すると新規作成が拒否される。
+- 完了済み（`completed: true`）のセッションは自動的にクリーンアップされる。
+
+#### WSL セッションサーバーの確認
+
+WSL セッションが使えない場合は、まずサーバーの稼働状態を確認する:
+
+```bash
+curl http://localhost:8080/api/terminal/wsl/status \
+  -H "Authorization: Bearer $API_TOKEN"
+```
+
+`running: false` の場合、ターゲットユーザーがログインしていない可能性がある。

package/win/routes/chat.js

@@ -116,17 +116,18 @@ async function chatRoutes(fastify) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { message, session_id, context, wsl_mode } = request.body || {}
+    const { message, session_id, context, wsl_mode, workspace_id } = request.body || {}
     if (!message || typeof message !== 'string') {
       reply.code(400)
       return { success: false, error: 'message is required' }
     }
 
+    const workspaceId = workspace_id || null
     const prompt = await buildContextPrefix(message, context, session_id)
     const currentSessionId = session_id || null
 
     if (currentSessionId) {
-      await chatStore.addMessage(currentSessionId, { role: 'user', content: message })
+      await chatStore.addMessage(currentSessionId, { role: 'user', content: message }, undefined, workspaceId)
     }
 
     reply.hijack()
@@ -144,7 +145,7 @@ async function chatRoutes(fastify) {
         await proxyWslChat(reply.raw, prompt, currentSessionId)
         wslModeActive = false
       } else {
-        await streamLlmResponse(reply.raw, prompt, currentSessionId)
+        await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message)
       }
     } catch (err) {
       wslModeActive = false
@@ -160,12 +161,14 @@ async function chatRoutes(fastify) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
-    const session = chatStore.load()
+    const workspaceId = request.query?.workspace_id || null
+    const session = chatStore.load(workspaceId)
     if (!session) return { success: true, session: null }
     return {
       success: true,
       session: {
         session_id: session.session_id,
+        workspace_id: session.workspace_id,
         messages: session.messages,
         turn_count: session.turn_count,
         created_at: session.created_at,
@@ -174,7 +177,7 @@ async function chatRoutes(fastify) {
     }
   })
 
-  // GET /api/chat/sessions - List all sessions (metadata only)
+  // GET /api/chat/sessions - List sessions, optionally filtered by workspace
   fastify.get('/api/chat/sessions', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
@@ -182,7 +185,8 @@ async function chatRoutes(fastify) {
     }
 
     const limit = parseInt(request.query?.limit) || 50
-    const sessions = chatStore.listSessions(limit)
+    const workspaceId = request.query?.workspace_id || undefined
+    const sessions = chatStore.listSessions(limit, workspaceId)
     return { success: true, sessions }
   })
 
@@ -207,7 +211,8 @@ async function chatRoutes(fastify) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
-    await chatStore.clear()
+    const workspaceId = request.body?.workspace_id || null
+    await chatStore.clear(workspaceId)
     return { success: true }
   })
 
@@ -239,40 +244,57 @@ async function chatRoutes(fastify) {
     return { success: true }
   })
 
-  // POST /api/chat/reset - Summarize conversation and start fresh session
+  // POST /api/chat/reset - Carry over relevant messages and start fresh session
   fastify.post('/api/chat/reset', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
-    const session = await chatStore.load()
+    const workspaceId = request.body?.workspace_id || null
+    const session = await chatStore.load(workspaceId)
     if (!session || session.messages.length === 0) {
-      await chatStore.clear()
-      return { success: true, summary: null }
+      await chatStore.clear(workspaceId)
+      return { success: true, carry_over: null }
     }
 
+    // Take recent messages for topic analysis
     const recentMessages = session.messages.slice(-20)
-    const conversationText = recentMessages
-      .map(m => `${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content.substring(0, 500)}`)
-      .join('\n\n')
-
-    const summarizePrompt = `以下の会話を要約してください。重要なコンテキスト、決定事項、進行中のタスクを含めてください。200文字以内で。\n\n${conversationText}`
+    let carryOverMessages = recentMessages
 
-    let summary = null
+    // Ask LLM to find where the current topic begins
     try {
-      summary = await runQuickLlmCall(summarizePrompt)
-    } catch (err) {
-      console.error('[Chat] summarization failed:', err.message)
-      const fallback = recentMessages.slice(-4)
-        .map(m => `${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content.substring(0, 200)}`)
+      const indexed = recentMessages
+        .map((m, i) => `[${i}] ${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content.substring(0, 300)}`)
         .join('\n')
-      summary = fallback
+
+      const analyzePrompt = `以下の会話履歴を分析し、現在進行中のトピックが始まったインデックス番号を特定してください。
+会話の流れが明確に変わったポイント（新しい質問・別の作業への切り替え等）がある場合、最後の切り替え以降のインデックスを返してください。
+全体が同じトピックの場合は 0 を返してください。
+
+数値のみを返してください（例: 5）。
+
+${indexed}`
+
+      const result = await runQuickLlmCall(analyzePrompt)
+      const breakIndex = parseInt(result.trim(), 10)
+      if (!isNaN(breakIndex) && breakIndex >= 0 && breakIndex < recentMessages.length) {
+        carryOverMessages = recentMessages.slice(breakIndex)
+        console.log(`[Chat] topic break at index ${breakIndex}, carrying over ${carryOverMessages.length}/${recentMessages.length} messages`)
+      }
+    } catch (err) {
+      console.error('[Chat] topic analysis failed, carrying over last 10:', err.message)
+      carryOverMessages = recentMessages.slice(-10)
     }
 
-    await chatStore.clear()
-    console.log(`[Chat] session reset with summary (${summary?.length || 0} chars)`)
-    return { success: true, summary }
+    // Format carry-over as conversation text
+    const carryOver = carryOverMessages
+      .map(m => `${m.role === 'user' ? 'ユーザー' : 'アシスタント'}: ${m.content}`)
+      .join('\n\n')
+
+    await chatStore.clear(workspaceId)
+    console.log(`[Chat] session reset, carrying over ${carryOverMessages.length} messages (${carryOver.length} chars)`)
+    return { success: true, carry_over: carryOver }
   })
 
   // POST /api/chat/end-of-day - Generate daily log + extract memories
@@ -394,7 +416,7 @@ function getLlmBinary() {
  * Tracks block types to correctly forward tool_use vs text events
  * and counts turns for session management.
  */
-function streamLlmResponse(res, prompt, sessionId) {
+function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage) {
   return new Promise((resolve, reject) => {
     const binaryName = getLlmBinary()
     if (!binaryName) {
@@ -542,10 +564,10 @@ function streamLlmResponse(res, prompt, sessionId) {
       activeChatChild = null
       if (resolvedSessionId) {
         if (!sessionId) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'user', content: prompt })
+          await chatStore.addMessage(resolvedSessionId, { role: 'user', content: originalMessage || prompt }, undefined, workspaceId)
         }
         if (fullResponse) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount)
+          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
         }
       }
       if (code !== 0 && !fullResponse) {
@@ -553,7 +575,7 @@ function streamLlmResponse(res, prompt, sessionId) {
         res.write(`data: ${JSON.stringify({ type: 'error', error: errorMsg })}\n\n`)
       }
 
-      const session = await chatStore.load()
+      const session = await chatStore.load(workspaceId)
       const totalTurnCount = session?.turn_count || turnCount
 
       res.write(`data: ${JSON.stringify({ type: 'done', session_id: resolvedSessionId, turn_count: totalTurnCount })}\n\n`)

package/win/routes/terminal.js

@@ -316,13 +316,26 @@ async function terminalRoutes(fastify) {
     if (type === 'wsl') {
       const sessionName = name || `wsl-session-${Date.now()}`
       const wslName = sessionName.startsWith('wsl-') ? sessionName : `wsl-${sessionName}`
+
+      // get_or_create: return existing session if it's still alive
+      if (request.body.get_or_create) {
+        const sessions = await proxyToWsl('GET', '/api/wsl/sessions')
+        if (sessions && sessions.success && sessions.sessions) {
+          const existing = sessions.sessions.find(s => s.name === wslName && !s.completed)
+          if (existing) {
+            console.log(`[Terminal] Reusing existing WSL session '${wslName}'`)
+            return { success: true, session: wslName, message: `Reusing existing WSL session '${wslName}'`, reused: true }
+          }
+        }
+      }
+
       console.log(`[Terminal] Creating WSL session '${wslName}' — proxying to WSL server`)
       const result = await proxyToWsl('POST', '/api/wsl/create', { name: wslName, command })
       if (!result) {
         reply.code(503)
         return { success: false, error: 'WSL session server is not running. The target user must be logged in for WSL sessions.' }
       }
-      reply.code(result.success ? 200 : 500)
+      reply.code(result.success ? 200 : (result.error?.includes('limit') ? 429 : 500))
       return result
     }
 

package/win/server.js

@@ -144,10 +144,12 @@ function syncBundledRules() {
   try {
     if (!fs.existsSync(bundledRulesDir)) return
     fs.mkdirSync(targetRulesDir, { recursive: true })
-    const coreSrc = path.join(bundledRulesDir, 'core.md')
-    if (fs.existsSync(coreSrc)) {
-      fs.copyFileSync(coreSrc, path.join(targetRulesDir, 'core.md'))
-      console.log('[Rules] Synced: core.md')
+    for (const ruleFile of ['core.md', 'windows.md']) {
+      const src = path.join(bundledRulesDir, ruleFile)
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, path.join(targetRulesDir, ruleFile))
+        console.log(`[Rules] Synced: ${ruleFile}`)
+      }
     }
     for (const legacy of ['minion.md', 'role-pm.md', 'role-engineer.md']) {
       const legacyPath = path.join(targetRulesDir, legacy)

package/win/wsl-session-server.js

@@ -29,6 +29,9 @@ const DATA_DIR = path.join(HOME_DIR, '.minion')
 const TOKEN_FILE = path.join(DATA_DIR, '.wsl-session-token')
 const PID_FILE = path.join(DATA_DIR, '.wsl-session.pid')
 
+const MAX_WSL_SESSIONS = 5
+const COMPLETED_SESSION_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
 let AUTH_TOKEN = ''
 try {
   AUTH_TOKEN = fs.readFileSync(TOKEN_FILE, 'utf-8').trim()
@@ -109,6 +112,7 @@ function createWslSession(sessionName, command) {
   ptyProcess.onExit(({ exitCode }) => {
     session.completed = true
     session.exitCode = exitCode
+    session.completedAt = Date.now()
     for (const ws of session.wsClients) {
       try { ws.close() } catch {}
     }
@@ -119,6 +123,30 @@ function createWslSession(sessionName, command) {
   return session
 }
 
+/**
+ * Remove completed sessions that have been idle for COMPLETED_SESSION_TTL_MS.
+ */
+function reapCompletedSessions() {
+  const now = Date.now()
+  for (const [name, session] of activeSessions) {
+    if (session.completed && session.completedAt && now - session.completedAt > COMPLETED_SESSION_TTL_MS) {
+      activeSessions.delete(name)
+      console.log(`[WSL] Reaped completed session '${name}'`)
+    }
+  }
+}
+
+/**
+ * Count active (non-completed) sessions.
+ */
+function activeSessionCount() {
+  let count = 0
+  for (const [, session] of activeSessions) {
+    if (!session.completed) count++
+  }
+  return count
+}
+
 const specialKeyMap = {
   'Enter': '\r', 'Escape': '\x1b', 'Tab': '\t',
   'C-c': '\x03', 'C-d': '\x04', 'C-z': '\x1a',
@@ -249,10 +277,24 @@ async function startServer() {
     if (!/^[\w-]+$/.test(sessionName)) {
       reply.code(400); return { success: false, error: 'Invalid session name' }
     }
+
+    // Reap completed sessions before checking limits
+    reapCompletedSessions()
+
     if (activeSessions.has(sessionName)) {
       reply.code(409); return { success: false, error: `Session '${sessionName}' already exists` }
     }
 
+    if (activeSessionCount() >= MAX_WSL_SESSIONS) {
+      reply.code(429)
+      return {
+        success: false,
+        error: `WSL session limit reached (max ${MAX_WSL_SESSIONS}). Kill unused sessions before creating new ones.`,
+        active_sessions: activeSessionCount(),
+        max_sessions: MAX_WSL_SESSIONS,
+      }
+    }
+
     try {
       createWslSession(sessionName, command)
       return { success: true, session: sessionName, message: `WSL session '${sessionName}' created` }
@@ -373,6 +415,9 @@ async function startServer() {
     fs.writeFileSync(PID_FILE, String(process.pid))
   } catch {}
 
+  // Periodically reap completed sessions
+  setInterval(reapCompletedSessions, 60 * 1000)
+
   return fastify
 }