@geekbeer/minion 2.33.4 → 2.42.5

package/win/server.js

@@ -14,12 +14,22 @@ const fastify = require('fastify')({ logger: true })
 
 // Compatible modules (reused from Linux)
 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
+
 // Windows-specific modules
 const workflowRunner = require('./workflow-runner')
 const routineRunner = require('./routine-runner')
+
+// Pull-model daemons (from core/)
+const stepPoller = require('../core/lib/step-poller')
+const revisionWatcher = require('../core/lib/revision-watcher')
 const { commandRoutes, getProcessManager, getAllowedCommands } = require('./routes/commands')
 const { terminalRoutes, cleanupSessions } = require('./routes/terminal')
 const { startTerminalServer, stopTerminalServer } = require('./terminal-server')
@@ -30,6 +40,7 @@ const { configRoutes } = require('./routes/config')
 
 // Compatible route modules (reused from Linux)
 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')
@@ -47,6 +58,27 @@ console.log(`[Config] Available commands: ${Object.keys(ALLOWED_COMMANDS).join('
 async function shutdown(signal) {
   console.log(`[Server] Received ${signal}, shutting down...`)
   setOffline()
+
+  // 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
+    }
+  }
+
+  stepPoller.stop()
+  revisionWatcher.stop()
   workflowRunner.stopAll()
   routineRunner.stopAll()
   stopTerminalServer()
@@ -155,6 +187,7 @@ function syncBundledDocs() {
 async function registerRoutes(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 })
@@ -218,6 +251,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/win/workflow-runner.js

@@ -9,11 +9,13 @@
  * - Exit codes captured via onExit callback (no file polling)
  * - Output logged via onData handler (replaces tmux pipe-pane)
  * - Sessions tracked in-memory via activeSessions Map
+ * - Outcome (success/failure) is determined by CLI exit code and recorded automatically
  */
 
 const { Cron } = require('croner')
 const crypto = require('crypto')
 const path = require('path')
+const { stripAnsi } = require('../core/lib/strip-ansi')
 const fs = require('fs').promises
 const fsSync = require('fs')
 
@@ -21,7 +23,7 @@ const { config } = require('../core/config')
 const executionStore = require('../core/stores/execution-store')
 const workflowStore = require('../core/stores/workflow-store')
 const logManager = require('../core/lib/log-manager')
-const { MARKER_DIR, buildExtendedPath } = require('../core/lib/platform')
+const { buildExtendedPath } = require('../core/lib/platform')
 
 // Active cron jobs keyed by workflow ID
 const activeJobs = new Map()
@@ -46,25 +48,6 @@ function generateSessionName(workflowId, executionId) {
   return execShort ? `wf-${workflowShort}-${execShort}` : `wf-${workflowShort}`
 }
 
-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}`)
-  }
-}
-
-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 */ }
-}
-
 /**
  * Load node-pty dynamically (it's an optionalDependency).
  * @returns {object} The node-pty module
@@ -100,15 +83,13 @@ 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}.`
 
   const extendedPath = buildExtendedPath(homeDir)
   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] Session: ${sessionName}`)
   console.log(`[WorkflowRunner] Log file: ${logFile}`)
   console.log(`[WorkflowRunner] HOME: ${homeDir}`)
@@ -124,15 +105,6 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
       activeSessions.delete(sessionName)
     }
 
-    // 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 LLM command
     if (!config.LLM_COMMAND) {
       throw new Error('LLM_COMMAND is not configured. Set LLM_COMMAND in minion.env')
@@ -146,9 +118,6 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
       HOME: homeDir,
       USERPROFILE: homeDir,
       PATH: extendedPath,
-      MINION_EXECUTION_ID: executionId,
-      MINION_WORKFLOW_ID: workflow.id,
-      MINION_WORKFLOW_NAME: workflow.name,
     }
 
     // Open log file for streaming writes
@@ -192,14 +161,15 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
       }, timeout)
 
       ptyProcess.onData((data) => {
-        outputBuffer += data
-        session.buffer += data
+        const cleaned = stripAnsi(data)
+        outputBuffer += cleaned
+        session.buffer += cleaned
         // Cap buffer at 1MB to prevent memory issues
         if (session.buffer.length > 1024 * 1024) {
           session.buffer = session.buffer.slice(-512 * 1024)
         }
         // Write to log file
-        try { logStream.write(data) } catch { /* ignore */ }
+        try { logStream.write(cleaned) } catch { /* ignore */ }
       })
 
       ptyProcess.onExit(({ exitCode }) => {
@@ -222,8 +192,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 {
-    await cleanupMarkerFile(sessionName)
   }
 }
 
@@ -273,14 +241,16 @@ async function runWorkflow(workflow, options = {}) {
 
   const result = await executeWorkflowSession(workflow, executionId, pipelineSkillNames, options)
   const completedAt = new Date().toISOString()
+  const outcome = result.success ? 'success' : 'failure'
 
+  // 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',
+    outcome,
     started_at: startedAt,
     completed_at: completedAt,
     parent_execution_id: null,
@@ -288,6 +258,25 @@ async function runWorkflow(workflow, options = {}) {
     log_file: logFile,
   })
 
+  // Report outcome via local API
+  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}`)
+  }
+
   await workflowStore.updateLastRun(workflow.id)
 
   runningExecutions.delete(executionId)
@@ -376,5 +365,4 @@ module.exports = {
   getWorkflowById,
   generateSessionName,
   activeSessions,
-  MARKER_DIR,
 }

package/skills/execution-report/SKILL.md

@@ -1,106 +0,0 @@
----
-name: execution-report
-description: Report workflow execution outcome to minion agent
----
-
-# Execution Report Skill
-
-## Overview
-
-This skill reports the outcome of a workflow execution to the minion agent. It is **automatically called at the end of every workflow** and should not be manually added to workflow pipelines.
-
-## How It Works
-
-1. Read the marker file to get execution metadata
-2. Analyze the results of all skills executed in this session
-3. Report the outcome to the minion API
-
-## Instructions
-
-### Step 1: Get Execution Context
-
-The execution context is provided via environment variables:
-
-```bash
-# Get execution context from environment
-EXECUTION_ID="${MINION_EXECUTION_ID}"
-WORKFLOW_ID="${MINION_WORKFLOW_ID}"
-WORKFLOW_NAME="${MINION_WORKFLOW_NAME}"
-```
-
-If the environment variables are not set, check the marker file as fallback:
-
-```bash
-# Fallback: Read from marker file
-if [ -z "$EXECUTION_ID" ]; then
-  SESSION_NAME=$(tmux display-message -p '#S' 2>/dev/null)
-  MARKER_FILE="/tmp/minion-executions/${SESSION_NAME}.json"
-  if [ -f "$MARKER_FILE" ]; then
-    EXECUTION_ID=$(cat "$MARKER_FILE" | grep -o '"execution_id": *"[^"]*"' | cut -d'"' -f4)
-  fi
-fi
-```
-
-**Expected values:**
-- `EXECUTION_ID`: UUID of the current execution
-- `WORKFLOW_ID`: UUID of the workflow
-- `WORKFLOW_NAME`: Human-readable workflow name
-
-### Step 2: Analyze Execution Results
-
-Review what happened during this session:
-
-- **outcome**: Choose one of:
-  - `success` - All skills completed successfully
-  - `failure` - Critical error occurred, objectives not met
-  - `partial` - Some skills succeeded, some failed or were skipped
-
-- **summary**: One-line summary of results (max 50 chars)
-
-- **details**: Detailed report in markdown format
-
-### Step 3: Report Outcome
-
-Use the EXECUTION_ID to report results:
-
-```bash
-curl -s -X POST "http://localhost:8080/api/executions/${EXECUTION_ID}/outcome" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "outcome": "success|failure|partial",
-    "summary": "Brief summary here",
-    "details": "## Detailed Report\n\n- Action 1\n- Action 2\n..."
-  }'
-```
-
-## Report Format (details field)
-
-```markdown
-## Execution Summary
-- Workflow: {workflow_name}
-- Skills: {skill_names}
-- Outcome: {outcome}
-
-## Actions Taken
-- [List of actions performed]
-
-## Artifacts
-- [Files created, messages sent, etc.]
-
-## Issues & Notes
-- [Errors or unexpected events]
-- [Notes for future runs]
-```
-
-## No Execution Context?
-
-If `MINION_EXECUTION_ID` is not set and the marker file doesn't exist, this is likely a manual execution. In this case:
-1. Log a warning: "No execution context found. Treating as manual execution."
-2. Skip the outcome API call (no execution record to update)
-
-## Important Notes
-
-- This skill is automatically appended to every workflow
-- Do NOT add it to workflow pipelines manually
-- Execution context is provided via `MINION_EXECUTION_ID`, `MINION_WORKFLOW_ID`, and `MINION_WORKFLOW_NAME` environment variables
-- The marker file is kept as a fallback and is cleaned up automatically after workflow completion