@geekbeer/minion 2.33.4 → 2.42.5

package/linux/routes/chat.js

@@ -12,6 +12,7 @@
  *   GET    /api/chat/session   - Get active session (messages + session_id)
  *   POST   /api/chat/clear     - Clear session and start fresh
  *   POST   /api/chat/abort     - Kill the active LLM CLI process
+ *   POST   /api/chat/reset     - Summarize conversation and start fresh session
  */
 
 const { spawn } = require('child_process')
@@ -136,6 +137,44 @@ async function chatRoutes(fastify) {
 
     return { success: true }
   })
+
+  // POST /api/chat/reset - Summarize conversation 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()
+    if (!session || session.messages.length === 0) {
+      await chatStore.clear()
+      return { success: true, summary: null }
+    }
+
+    // Build summarization prompt from recent messages
+    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 summary = null
+    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)}`)
+        .join('\n')
+      summary = fallback
+    }
+
+    await chatStore.clear()
+    console.log(`[Chat] session reset with summary (${summary?.length || 0} chars)`)
+    return { success: true, summary }
+  })
 }
 
 /**
@@ -210,8 +249,8 @@ function getLlmBinary() {
 /**
  * Stream LLM CLI output as SSE events.
  * Uses --resume to continue existing sessions.
- * Note: Chat-specific flags (--output-format stream-json, --resume, etc.)
- * are Claude Code CLI features. Other LLM CLIs may not support them.
+ * Tracks block types to correctly forward tool_use vs text events
+ * and counts turns for session management.
  */
 function streamLlmResponse(res, prompt, sessionId) {
   return new Promise((resolve, reject) => {
@@ -275,6 +314,12 @@ function streamLlmResponse(res, prompt, sessionId) {
     let lineBuffer = ''
     let resolvedSessionId = sessionId || null
 
+    // Block-type state tracking for correct event forwarding
+    let currentBlockType = null  // 'text' | 'tool_use' | null
+    let currentToolName = null
+    let toolInputBuffer = ''
+    let turnCount = 0
+
     child.stdout.on('data', (data) => {
       lineBuffer += data.toString()
       const parts = lineBuffer.split('\n')
@@ -292,18 +337,68 @@ function streamLlmResponse(res, prompt, sessionId) {
             console.log(`[Chat] session_id: ${resolvedSessionId}`)
           }
 
-          // tool_use events — forward to frontend for progress display
-          if (parsed.type === 'content_block_start' && parsed.content_block?.type === 'tool_use') {
-            const event = JSON.stringify({ type: 'tool_start', tool: parsed.content_block.name || 'unknown' })
-            res.write(`data: ${event}\n\n`)
+          // content_block_start — track block type
+          if (parsed.type === 'content_block_start') {
+            const blockType = parsed.content_block?.type
+            if (blockType === 'tool_use') {
+              currentBlockType = 'tool_use'
+              currentToolName = parsed.content_block.name || 'unknown'
+              toolInputBuffer = ''
+              const event = JSON.stringify({
+                type: 'tool_start',
+                tool: currentToolName,
+              })
+              res.write(`data: ${event}\n\n`)
+            } else if (blockType === 'text') {
+              currentBlockType = 'text'
+            }
           }
+
+          // content_block_delta — handle both text and tool input
+          if (parsed.type === 'content_block_delta') {
+            const deltaType = parsed.delta?.type
+            if (deltaType === 'input_json_delta' && currentBlockType === 'tool_use') {
+              // Accumulate tool input JSON
+              const partial = parsed.delta.partial_json || ''
+              if (partial) {
+                toolInputBuffer += partial
+                const event = JSON.stringify({ type: 'tool_input_delta', partial_json: partial })
+                res.write(`data: ${event}\n\n`)
+              }
+            } else {
+              // Text delta
+              const delta = parsed.delta?.text || ''
+              if (delta) {
+                fullResponse += delta
+                const event = JSON.stringify({ type: 'delta', content: delta })
+                res.write(`data: ${event}\n\n`)
+              }
+            }
+          }
+
+          // content_block_stop — only emit tool_end for tool_use blocks (bug fix)
           if (parsed.type === 'content_block_stop') {
-            const event = JSON.stringify({ type: 'tool_end' })
-            res.write(`data: ${event}\n\n`)
+            if (currentBlockType === 'tool_use') {
+              // Try to parse the accumulated tool input
+              let parsedInput = null
+              try {
+                if (toolInputBuffer) parsedInput = JSON.parse(toolInputBuffer)
+              } catch { /* partial or invalid JSON */ }
+              const event = JSON.stringify({
+                type: 'tool_end',
+                tool: currentToolName,
+                input: parsedInput,
+              })
+              res.write(`data: ${event}\n\n`)
+            }
+            currentBlockType = null
+            currentToolName = null
+            toolInputBuffer = ''
           }
 
-          // assistant message content blocks
+          // assistant message — count turns and forward text blocks
           if (parsed.type === 'assistant' && parsed.message) {
+            turnCount++
             for (const block of (parsed.message.content || [])) {
               if (block.type === 'text') {
                 fullResponse += block.text
@@ -311,20 +406,17 @@ function streamLlmResponse(res, prompt, sessionId) {
                 res.write(`data: ${event}\n\n`)
               }
             }
-          } else if (parsed.type === 'content_block_delta') {
-            const delta = parsed.delta?.text || ''
-            if (delta) {
-              fullResponse += delta
-              const event = JSON.stringify({ type: 'delta', content: delta })
-              res.write(`data: ${event}\n\n`)
-            }
           } else if (parsed.type === 'result') {
-            // result event — send as 'result' type for frontend to use as final text
+            // result event — forward but do NOT overwrite accumulated fullResponse
             const resultText = parsed.result || ''
             if (resultText) {
               const event = JSON.stringify({ type: 'result', content: resultText })
               res.write(`data: ${event}\n\n`)
-              fullResponse = resultText
+              // Use result as fullResponse only if nothing was accumulated
+              // (single-turn responses without deltas)
+              if (!fullResponse) {
+                fullResponse = resultText
+              }
             }
           }
         } catch {
@@ -349,9 +441,9 @@ function streamLlmResponse(res, prompt, sessionId) {
         if (!sessionId) {
           await chatStore.addMessage(resolvedSessionId, { role: 'user', content: prompt })
         }
-        // Store assistant response
+        // Store assistant response with turn count
         if (fullResponse) {
-          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse })
+          await chatStore.addMessage(resolvedSessionId, { role: 'assistant', content: fullResponse }, turnCount)
         }
       }
 
@@ -363,9 +455,14 @@ function streamLlmResponse(res, prompt, sessionId) {
         res.write(`data: ${errorEvent}\n\n`)
       }
 
+      // Load current turn count from session for the done event
+      const session = await chatStore.load()
+      const totalTurnCount = session?.turn_count || turnCount
+
       const doneEvent = JSON.stringify({
         type: 'done',
         session_id: resolvedSessionId,
+        turn_count: totalTurnCount,
       })
       res.write(`data: ${doneEvent}\n\n`)
       resolve()
@@ -386,4 +483,69 @@ function streamLlmResponse(res, prompt, sessionId) {
   })
 }
 
+/**
+ * Run a quick non-streaming LLM call (for summarization etc.)
+ * Uses -p with json output format, no --resume.
+ * @param {string} prompt
+ * @returns {Promise<string>} The result text
+ */
+function runQuickLlmCall(prompt) {
+  return new Promise((resolve, reject) => {
+    const binaryName = getLlmBinary()
+    if (!binaryName) {
+      reject(new Error('LLM_COMMAND is not configured'))
+      return
+    }
+    const binaryPath = path.join(config.HOME_DIR, '.local', 'bin', binaryName)
+    const binary = fs.existsSync(binaryPath) ? binaryPath : binaryName
+
+    const extendedPath = [
+      `${config.HOME_DIR}/bin`,
+      `${config.HOME_DIR}/.npm-global/bin`,
+      `${config.HOME_DIR}/.local/bin`,
+      `${config.HOME_DIR}/.claude/bin`,
+      '/usr/local/bin',
+      '/usr/bin',
+      '/bin',
+    ].join(':')
+
+    const args = ['-p', '--model', 'haiku', '--max-turns', '1', '--output-format', 'json', prompt]
+
+    const child = spawn(binary, args, {
+      cwd: config.HOME_DIR,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 30000,
+      env: {
+        ...process.env,
+        HOME: config.HOME_DIR,
+        PATH: extendedPath,
+        DISPLAY: ':99',
+      },
+    })
+
+    child.stdin.end()
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (data) => { stdout += data.toString() })
+    child.stderr.on('data', (data) => { stderr += data.toString() })
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`LLM call failed (exit ${code}): ${stderr.substring(0, 200)}`))
+        return
+      }
+      try {
+        const parsed = JSON.parse(stdout)
+        resolve(parsed.result || stdout.trim())
+      } catch {
+        resolve(stdout.trim())
+      }
+    })
+
+    child.on('error', (err) => reject(err))
+  })
+}
+
 module.exports = { chatRoutes }

package/linux/routes/config.js

@@ -12,7 +12,8 @@ const fs = require('fs')
 const path = require('path')
 const { verifyToken } = require('../../core/lib/auth')
 const { clearLlmCache } = require('../../core/lib/llm-checker')
-const { config } = require('../../core/config')
+const { config, updateConfig } = require('../../core/config')
+const { resolveEnvFilePath: resolveEnvFilePathFromPlatform } = require('../../core/lib/platform')
 
 /** Keys that can be read/written via the config API */
 const ALLOWED_ENV_KEYS = ['LLM_COMMAND']
@@ -26,18 +27,10 @@ const BACKUP_PATHS = [
 
 /**
  * Resolve the .env file path.
- * Prefers /opt/minion-agent/.env (systemd/supervisord installs),
- * falls back to ~/minion.env (standalone/dev).
- * Checks that the directory is writable by the current process.
+ * Delegates to core/lib/platform.js for cross-platform consistency.
  */
 function resolveEnvFilePath() {
-  const optPath = '/opt/minion-agent/.env'
-  try {
-    fs.accessSync(path.dirname(optPath), fs.constants.W_OK)
-    return optPath
-  } catch {
-    return path.join(config.HOME_DIR, 'minion.env')
-  }
+  return resolveEnvFilePathFromPlatform(config.HOME_DIR)
 }
 
 /**
@@ -235,10 +228,13 @@ function configRoutes(fastify, _opts, done) {
       writeEnvKey(envPath, key, value)
       console.log(`[Config] Updated ${key} in ${envPath}`)
 
+      // Sync in-memory config so the change takes effect without restart
+      updateConfig(key, value)
+
       // Clear LLM cache so health check reflects immediately
       clearLlmCache()
 
-      return { success: true, restart_required: true }
+      return { success: true, restart_required: false }
     } catch (err) {
       console.error(`[Config] Failed to update ${key} in ${envPath}:`, err.message)
       const detail = err.code === 'EACCES' ? ' (permission denied)' : ''

package/linux/routine-runner.js

@@ -189,17 +189,18 @@ async function executeRoutineSession(routine, executionId, skillNames) {
     console.log(`[RoutineRunner] Started tmux session: ${sessionName}`)
 
     // Wait for session to complete (poll for exit code file)
+    // Note: use fs.access on exitCodeFile (not tmux has-session) because
+    // remain-on-exit keeps the session alive after command completes.
     const timeout = 60 * 60 * 1000 // 60 minutes
     const pollInterval = 2000 // 2 seconds
     const startTime = Date.now()
 
     while (Date.now() - startTime < timeout) {
       try {
-        await execAsync(`tmux has-session -t "${sessionName}" 2>/dev/null`)
-        await sleep(pollInterval)
+        await fs.access(exitCodeFile)
+        break // Exit code file exists — CLI has finished
       } catch {
-        // Session ended
-        break
+        await sleep(pollInterval)
       }
     }
 

package/linux/server.js

@@ -31,17 +31,28 @@ const PACKAGE_ROOT = path.join(__dirname, '..')
 
 // Core shared modules
 const { config, validate, isHqConfigured } = require('../core/config')
+const { sendHeartbeat } = require('../core/api')
+const { version } = require('../package.json')
 const workflowStore = require('../core/stores/workflow-store')
 const routineStore = require('../core/stores/routine-store')
 
+// Heartbeat interval: fixed at 30s (not user-configurable)
+const HEARTBEAT_INTERVAL_MS = 30_000
+let heartbeatTimer = null
+
 // Linux-specific modules
 const workflowRunner = require('./workflow-runner')
 const routineRunner = require('./routine-runner')
 const { cleanupTtyd, killStaleTtydProcesses } = require('./routes/terminal')
 const { startTerminalProxy, stopTerminalProxy } = require('./terminal-proxy')
 
+// Pull-model daemons (from core/)
+const stepPoller = require('../core/lib/step-poller')
+const revisionWatcher = require('../core/lib/revision-watcher')
+
 // Shared routes (from core/)
 const { healthRoutes, setOffline } = require('../core/routes/health')
+const { diagnoseRoutes } = require('../core/routes/diagnose')
 const { skillRoutes } = require('../core/routes/skills')
 const { workflowRoutes } = require('../core/routes/workflows')
 const { routineRoutes } = require('../core/routes/routines')
@@ -68,7 +79,27 @@ async function shutdown(signal) {
 
   setOffline()
 
-  // Stop workflow and routine runners
+  // Stop heartbeat timer
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer)
+    heartbeatTimer = null
+  }
+
+  // Send offline heartbeat to HQ (best-effort, don't block shutdown)
+  if (isHqConfigured()) {
+    try {
+      await Promise.race([
+        sendHeartbeat({ status: 'offline', version }),
+        new Promise(resolve => setTimeout(resolve, 3000)),
+      ])
+    } catch {
+      // Best-effort — don't block shutdown
+    }
+  }
+
+  // Stop pollers and runners
+  stepPoller.stop()
+  revisionWatcher.stop()
   workflowRunner.stopAll()
   routineRunner.stopAll()
 
@@ -216,6 +247,7 @@ function syncBundledDocs() {
 async function registerAllRoutes(app) {
   // Shared routes (from core/) - inject runners via opts
   await app.register(healthRoutes)
+  await app.register(diagnoseRoutes)
   await app.register(skillRoutes, { workflowRunner })
   await app.register(workflowRoutes, { workflowRunner })
   await app.register(routineRoutes, { routineRunner })
@@ -281,6 +313,26 @@ async function start() {
 
     if (isHqConfigured()) {
       console.log(`[Server] HQ URL: ${config.HQ_URL}`)
+
+      // Send initial online heartbeat
+      const { getStatus } = require('../core/routes/health')
+      const { currentTask } = getStatus()
+      sendHeartbeat({ status: 'online', current_task: currentTask, version }).catch(err => {
+        console.error('[Heartbeat] Initial heartbeat failed:', err.message)
+      })
+
+      // Start periodic heartbeat
+      heartbeatTimer = setInterval(() => {
+        const { currentStatus, currentTask } = getStatus()
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, version }).catch(err => {
+          console.error('[Heartbeat] Periodic heartbeat failed:', err.message)
+        })
+      }, HEARTBEAT_INTERVAL_MS)
+      console.log(`[Heartbeat] Sending every ${HEARTBEAT_INTERVAL_MS / 1000}s`)
+
+      // Start Pull-model daemons
+      stepPoller.start()
+      revisionWatcher.start()
     } else {
       console.log('[Server] Running in standalone mode (no HQ connection)')
     }

package/linux/workflow-runner.js

@@ -6,8 +6,7 @@
  *
  * Key design:
  * - All skills in a workflow run in ONE CLI session (context preserved)
- * - /execution-report is automatically appended to report outcome
- * - Marker file written before session start for skill-to-execution mapping
+ * - Outcome (success/failure) is determined by CLI exit code and recorded automatically
  */
 
 const { Cron } = require('croner')
@@ -29,9 +28,6 @@ const activeJobs = new Map()
 // Currently running executions
 const runningExecutions = new Map()
 
-// Marker file directory
-const MARKER_DIR = '/tmp/minion-executions'
-
 /**
  * Sleep for specified milliseconds
  * @param {number} ms - Milliseconds to sleep
@@ -54,36 +50,6 @@ function generateSessionName(workflowId, executionId) {
   return execShort ? `wf-${workflowShort}-${execShort}` : `wf-${workflowShort}`
 }
 
-/**
- * Write execution marker file for skill to read
- * @param {string} sessionName - tmux session name
- * @param {object} data - Execution metadata
- */
-async function writeMarkerFile(sessionName, data) {
-  try {
-    await fs.mkdir(MARKER_DIR, { recursive: true })
-    const filePath = path.join(MARKER_DIR, `${sessionName}.json`)
-    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
-    console.log(`[WorkflowRunner] Wrote marker file: ${filePath}`)
-  } catch (err) {
-    console.error(`[WorkflowRunner] Failed to write marker file: ${err.message}`)
-  }
-}
-
-/**
- * Clean up marker file after execution
- * @param {string} sessionName - tmux session name
- */
-async function cleanupMarkerFile(sessionName) {
-  try {
-    const filePath = path.join(MARKER_DIR, `${sessionName}.json`)
-    await fs.unlink(filePath)
-    console.log(`[WorkflowRunner] Cleaned up marker file: ${filePath}`)
-  } catch {
-    // Ignore if file doesn't exist
-  }
-}
-
 /**
  * Execute a workflow in a single CLI session
  * All skills run sequentially with context preserved.
@@ -95,8 +61,6 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
   const sessionName = generateSessionName(workflow.id, executionId)
 
   // Build prompt: run each skill in sequence
-  // When skipExecutionReport is true (dispatched step), the minion server's
-  // post-execution hook handles completion reporting instead of /execution-report.
   const skillCommands = skillNames.map(name => `/${name}`).join(', then ')
 
   // Inject role context if provided (e.g. "pm" or "engineer")
@@ -109,9 +73,7 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
     ? `## Revision Feedback\nThe reviewer requested changes to your previous output. Address the following feedback:\n${options.revisionFeedback}\n\n`
     : ''
 
-  const prompt = options.skipExecutionReport
-    ? `${rolePrefix}${revisionContext}Run the following skills in order: ${skillCommands}.`
-    : `${rolePrefix}${revisionContext}Run the following skills in order: ${skillCommands}. After completing all skills, run /execution-report to report the results.`
+  const prompt = `${rolePrefix}${revisionContext}Run the following skills in order: ${skillCommands}.`
 
   // Extend PATH to include common CLI installation locations
   const additionalPaths = [
@@ -131,7 +93,7 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
   const logFile = logManager.getLogPath(executionId)
 
   console.log(`[WorkflowRunner] Executing workflow: ${workflow.name}`)
-  console.log(`[WorkflowRunner] Skills: ${skillNames.join(' → ')} → execution-report`)
+  console.log(`[WorkflowRunner] Skills: ${skillNames.join(' → ')}`)
   console.log(`[WorkflowRunner] tmux session: ${sessionName}`)
   console.log(`[WorkflowRunner] Log file: ${logFile}`)
   console.log(`[WorkflowRunner] HOME: ${homeDir}`)
@@ -147,15 +109,6 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
     // Remove old exit code file
     await execAsync(`rm -f "${exitCodeFile}"`)
 
-    // Write marker file BEFORE starting session
-    await writeMarkerFile(sessionName, {
-      execution_id: executionId,
-      workflow_id: workflow.id,
-      workflow_name: workflow.name,
-      skill_names: skillNames,
-      started_at: new Date().toISOString(),
-    })
-
     // Build the command to run in tmux
     if (!config.LLM_COMMAND) {
       throw new Error('LLM_COMMAND is not configured. Set LLM_COMMAND in minion.env (e.g., LLM_COMMAND="claude -p \'{prompt}\'")')
@@ -165,7 +118,6 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
     const execCommand = `${llmCommand}; echo $? > ${exitCodeFile}`
 
     // Create tmux session with extended environment
-    // Pass execution context as environment variables for /execution-report skill
     const tmuxCommand = [
       'tmux new-session -d',
       `-s "${sessionName}"`,
@@ -173,9 +125,6 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
       `-e "DISPLAY=:99"`,
       `-e "PATH=${extendedPath}"`,
       `-e "HOME=${homeDir}"`,
-      `-e "MINION_EXECUTION_ID=${executionId}"`,
-      `-e "MINION_WORKFLOW_ID=${workflow.id}"`,
-      `-e "MINION_WORKFLOW_NAME=${workflow.name.replace(/"/g, '\\"')}"`,
       `"${execCommand}"`,
     ].join(' ')
 
@@ -240,9 +189,6 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
   } catch (error) {
     console.error(`[WorkflowRunner] Workflow ${workflow.name} failed: ${error.message}`)
     return { success: false, error: error.message, sessionName }
-  } finally {
-    // Clean up marker file
-    await cleanupMarkerFile(sessionName)
   }
 }
 
@@ -306,17 +252,17 @@ async function runWorkflow(workflow, options = {}) {
   const result = await executeWorkflowSession(workflow, executionId, pipelineSkillNames, options)
 
   const completedAt = new Date().toISOString()
+  const outcome = result.success ? 'success' : 'failure'
   console.log(`[WorkflowRunner] executeWorkflowSession returned: success=${result.success}, error=${result.error || 'none'}`)
 
-  // Save: workflow completed (outcome may be updated later by /execution-report)
-  // If CLI exited with error, mark as failed; otherwise mark as completed (pending outcome)
+  // Save execution with outcome determined by CLI exit code
   await saveExecution({
     id: executionId,
     skill_name: pipelineSkillNames.join(' → '),
     workflow_id: workflow.id,
     workflow_name: workflow.name,
     status: result.success ? 'completed' : 'failed',
-    outcome: result.success ? null : 'failure', // null = pending outcome from /execution-report
+    outcome,
     started_at: startedAt,
     completed_at: completedAt,
     parent_execution_id: null,
@@ -324,6 +270,25 @@ async function runWorkflow(workflow, options = {}) {
     log_file: logFile,
   })
 
+  // Report outcome via local API (same data the execution-report skill used to send)
+  try {
+    const resp = await fetch(`http://localhost:${config.AGENT_PORT || 8080}/api/executions/${executionId}/outcome`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        outcome,
+        summary: result.success
+          ? `All skills completed successfully: ${pipelineSkillNames.join(', ')}`
+          : `Workflow failed: ${result.error || 'unknown error'}`,
+      }),
+    })
+    if (!resp.ok) {
+      console.error(`[WorkflowRunner] Failed to report outcome: ${resp.status}`)
+    }
+  } catch (err) {
+    console.error(`[WorkflowRunner] Failed to report outcome: ${err.message}`)
+  }
+
   // Update last_run in local store
   await workflowStore.updateLastRun(workflow.id)
 
@@ -438,5 +403,4 @@ module.exports = {
   runWorkflow,
   getWorkflowById,
   generateSessionName,
-  MARKER_DIR,
 }

package/package.json

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

package/roles/pm.md

@@ -6,26 +6,25 @@
 
 - **ワークフロー管理**: ワークフローの作成・修正・バージョン管理
 - **プロジェクトコンテキスト管理**: プロジェクトの共有コンテキスト（markdown）の更新
-- **オーケストレーション**: ワークフローステップのディスパッチ、エンジニアミニオンへの指示
 - **レビュー**: `requires_review=true` のステップの承認判断
 
 ## Workflow Execution Model
 
-ワークフロー実行はHQのDBがステートマシンとして管理する。ミニオン間の直接通信は不要。
+ワークフロー実行はPMミニオンのランタイム（Node.js）がオーケストレーションする。
+HQのDBがステートマシンとして状態を管理し、ミニオン間の直接通信は不要。
 
 ```
-1. Execution 作成 → workflow_execution + 全 step_executions (status='pending')
-2. ミニオンエージェントが GET /api/minion/pending-steps をポーリング
-   → 自分のロールに該当 & 前ステップ完了済みのステップを取得
-3. ミニオンがステップを実行し完了を報告
-4. 次ステップが eligible に → 別のミニオンが検知して実行
+1. HQ が Execution 作成 → workflow_execution + 全 step_executions (status='pending')
+2. HQ が PM ミニオンの POST /api/workflows/orchestrate を呼び出し
+3. PM ランタイムが各ステップを順次 dispatch → ステータスポーリング → レビューゲート処理
+4. レビューで差し戻しが発生した場合、LLM で差し戻し先を判断しリセット
 5. 全ステップ完了 → execution 全体を completed に
 ```
 
 ポイント:
-- HQの責務は「executionレコードを作る（指示書発行）」だけ
-- 各ミニオンは自分の担当ステップだけをポーリングして実行
-- ミニオンエージェント（Port 8080）が軽量HTTPポーリングを行い、pending検知時のみClaude Codeを起動
+- オーケストレーションはコード（workflow-orchestrator.js）で決定論的に実行
+- 差し戻し判断のみ LLM を使用（Anthropic API 直接呼び出し、フォールバック付き）
+- `~/.minion/revision-policy.md` でPM固有の差し戻しポリシーをカスタマイズ可能
 
 ## Workflow 管理
 
@@ -45,11 +44,11 @@
 
 ## Routine (従来方式)
 
-ワークフローは `project-workflow-check` システムスキルを通じてルーティンからも実行可能:
+ワークフローは `project-workflow-check` スキルを通じてルーティンからも実行可能:
 
 ```
 ルーティン: "morning-work" (cron: 0 9 * * 1-5)
-  pipeline: [project-workflow-check, execution-report]
+  pipeline: [project-workflow-check]
     ↓
   project-workflow-check:
     1. GET /api/minion/me/projects → 参加プロジェクト一覧