@geekbeer/minion 2.44.0 → 2.46.1

package/core/lib/capability-checker.js

@@ -0,0 +1,105 @@
+/**
+ * Capability checker
+ *
+ * Detects MCP servers configured in ~/.mcp.json and available CLI tools.
+ * Results are cached in memory for 5 minutes to avoid excessive filesystem/process checks.
+ * Follows the same caching pattern as llm-checker.js.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+const { config } = require('../config')
+const { IS_WINDOWS, buildExtendedPath } = require('./platform')
+
+const CACHE_TTL_MS = 300000 // 5 minutes
+
+let cachedResult = null
+let cachedAt = 0
+
+/**
+ * Detect MCP servers from ~/.mcp.json.
+ * Parses the Claude Code MCP configuration and returns configured server names.
+ * @returns {{ name: string, configured: boolean }[]}
+ */
+function getMcpServers() {
+  const mcpPath = path.join(config.HOME_DIR, '.mcp.json')
+  try {
+    if (!fs.existsSync(mcpPath)) return []
+    const content = fs.readFileSync(mcpPath, 'utf-8')
+    const parsed = JSON.parse(content)
+    const servers = parsed.mcpServers || parsed.servers || {}
+    return Object.keys(servers).map(name => ({
+      name,
+      configured: true,
+    }))
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Check if a CLI tool is available and get its version.
+ * @param {string} name - Tool name (e.g., 'git', 'node')
+ * @returns {{ name: string, available: boolean, version?: string }}
+ */
+function checkTool(name) {
+  const extendedPath = buildExtendedPath(config.HOME_DIR)
+  const env = {
+    ...process.env,
+    HOME: config.HOME_DIR,
+    ...(IS_WINDOWS && { USERPROFILE: config.HOME_DIR }),
+    PATH: extendedPath,
+  }
+  const execOpts = { encoding: 'utf-8', timeout: 5000, stdio: 'pipe', env }
+
+  try {
+    // Check existence
+    const whichCmd = IS_WINDOWS ? 'where' : 'which'
+    execSync(`${whichCmd} ${name}`, execOpts)
+
+    // Get version
+    let version = null
+    try {
+      const out = execSync(`${name} --version`, execOpts).trim()
+      // Extract version number from output (e.g., "git version 2.43.0" → "2.43.0")
+      const match = out.match(/(\d+\.\d+[\.\d]*)/)
+      if (match) version = match[1]
+    } catch {
+      // Tool exists but --version failed, that's ok
+    }
+
+    return { name, available: true, ...(version && { version }) }
+  } catch {
+    return { name, available: false }
+  }
+}
+
+/** CLI tools to detect */
+const TOOL_NAMES = ['git', 'node', 'npx', 'claude', 'docker', 'tmux']
+
+/**
+ * Get all capabilities (MCP servers + CLI tools), cached for 5 minutes.
+ * @returns {{ mcp_servers: { name: string, configured: boolean }[], cli_tools: { name: string, available: boolean, version?: string }[] }}
+ */
+function getCapabilities() {
+  const now = Date.now()
+  if (cachedResult && (now - cachedAt) < CACHE_TTL_MS) {
+    return cachedResult
+  }
+
+  const mcp_servers = getMcpServers()
+  const cli_tools = TOOL_NAMES.map(name => checkTool(name))
+
+  cachedResult = { mcp_servers, cli_tools }
+  cachedAt = now
+  return cachedResult
+}
+
+/** Clear the cached capability status */
+function clearCapabilityCache() {
+  cachedResult = null
+  cachedAt = 0
+}
+
+module.exports = { getCapabilities, clearCapabilityCache }

package/core/lib/step-poller.js

@@ -94,6 +94,7 @@ async function executeStep(step) {
     assigned_role,
     skill_name,
     revision_feedback,
+    extra_env,
   } = step
 
   console.log(
@@ -151,6 +152,9 @@ async function executeStep(step) {
     if (revision_feedback) {
       runPayload.revision_feedback = revision_feedback
     }
+    if (extra_env && typeof extra_env === 'object') {
+      runPayload.extra_env = extra_env
+    }
 
     const runUrl = `http://localhost:${config.AGENT_PORT || 8080}/api/skills/run`
     const runResp = await fetch(runUrl, {

package/core/routes/health.js

@@ -11,6 +11,7 @@ const { version } = require('../../package.json')
 const { config, isHqConfigured } = require('../config')
 const { sendHeartbeat } = require('../api')
 const { getLlmServices, isLlmCommandConfigured } = require('../lib/llm-checker')
+const { getCapabilities } = require('../lib/capability-checker')
 
 function maskToken(token) {
   if (!token || token.length < 8) return token ? '***' : ''
@@ -58,6 +59,7 @@ async function healthRoutes(fastify) {
       timestamp: new Date().toISOString(),
       llm_services: getLlmServices(),
       llm_command_configured: isLlmCommandConfigured(),
+      capabilities: getCapabilities(),
       env: {
         HQ_URL: config.HQ_URL || '',
         MINION_ID: config.MINION_ID || '',

package/core/routes/skills.js

@@ -291,7 +291,7 @@ async function skillRoutes(fastify, opts) {
       return { success: false, error: 'Unauthorized' }
     }
 
-    const { skill_name, execution_id, step_index, workflow_name, role, revision_feedback } = request.body || {}
+    const { skill_name, execution_id, step_index, workflow_name, role, revision_feedback, extra_env } = request.body || {}
 
     if (!skill_name) {
       reply.code(400)
@@ -340,6 +340,7 @@ async function skillRoutes(fastify, opts) {
     const runOptions = {}
     if (role) runOptions.role = role
     if (revision_feedback) runOptions.revisionFeedback = revision_feedback
+    if (extra_env && typeof extra_env === 'object') runOptions.extraEnv = extra_env
 
     // Run asynchronously — respond immediately
     const executionPromise = (async () => {

package/core/routes/variables.js

@@ -0,0 +1,131 @@
+/**
+ * Variables & Secrets routes (shared between Linux and Windows)
+ *
+ * Minion Variables:
+ *   GET    /api/variables           - List all variables (key + value)
+ *   GET    /api/variables/:key      - Get a single variable
+ *   PUT    /api/variables/:key      - Set a variable
+ *   DELETE /api/variables/:key      - Delete a variable
+ *
+ * Minion Secrets:
+ *   GET    /api/secrets             - List secret keys only (no values)
+ *   PUT    /api/secrets/:key        - Set a secret
+ *   DELETE /api/secrets/:key        - Delete a secret
+ *
+ * All endpoints require Bearer token authentication.
+ */
+
+const variableStore = require('../stores/variable-store')
+const { verifyToken } = require('../lib/auth')
+
+/** Validate a key name: alphanumeric + underscores, 1-100 chars */
+function isValidKey(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]{0,99}$/.test(key)
+}
+
+/** Validate a value: no newlines, max 2000 chars */
+function isValidValue(value) {
+  if (typeof value !== 'string') return false
+  if (value.includes('\n') || value.includes('\r')) return false
+  if (value.length > 2000) return false
+  return true
+}
+
+function variableRoutes(fastify, _opts, done) {
+  // ─── Variables (non-sensitive) ───────────────────────────────────────
+
+  fastify.get('/api/variables', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const variables = variableStore.getAll('variables')
+    return { success: true, variables }
+  })
+
+  fastify.get('/api/variables/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const value = variableStore.get('variables', key)
+    if (value === null) {
+      return reply.code(404).send({ error: `Variable not found: ${key}` })
+    }
+    return { success: true, key, value }
+  })
+
+  fastify.put('/api/variables/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const { value } = request.body || {}
+
+    if (!isValidKey(key)) {
+      return reply.code(400).send({ error: 'Invalid key. Use alphanumeric characters and underscores (1-100 chars).' })
+    }
+    if (!isValidValue(value)) {
+      return reply.code(400).send({ error: 'Invalid value. Must be a string, no newlines, max 2000 chars.' })
+    }
+
+    variableStore.set('variables', key, value)
+    return { success: true, key, value }
+  })
+
+  fastify.delete('/api/variables/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const removed = variableStore.remove('variables', key)
+    if (!removed) {
+      return reply.code(404).send({ error: `Variable not found: ${key}` })
+    }
+    return { success: true, key }
+  })
+
+  // ─── Secrets (sensitive) ─────────────────────────────────────────────
+
+  fastify.get('/api/secrets', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    // Return keys only — never expose secret values via API
+    const keys = variableStore.listKeys('secrets')
+    return { success: true, keys }
+  })
+
+  fastify.put('/api/secrets/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const { value } = request.body || {}
+
+    if (!isValidKey(key)) {
+      return reply.code(400).send({ error: 'Invalid key. Use alphanumeric characters and underscores (1-100 chars).' })
+    }
+    if (!isValidValue(value)) {
+      return reply.code(400).send({ error: 'Invalid value. Must be a string, no newlines, max 2000 chars.' })
+    }
+
+    variableStore.set('secrets', key, value)
+    return { success: true, key }
+  })
+
+  fastify.delete('/api/secrets/:key', async (request, reply) => {
+    if (!verifyToken(request)) {
+      return reply.code(401).send({ error: 'Unauthorized' })
+    }
+    const { key } = request.params
+    const removed = variableStore.remove('secrets', key)
+    if (!removed) {
+      return reply.code(404).send({ error: `Secret not found: ${key}` })
+    }
+    return { success: true, key }
+  })
+
+  done()
+}
+
+module.exports = { variableRoutes }

package/core/stores/variable-store.js

@@ -0,0 +1,152 @@
+/**
+ * Variable Store
+ *
+ * Manages minion-local secrets and variables stored in .env-style files.
+ * - Secrets: ~/.minion/.env.secrets (or DATA_DIR/.env.secrets)
+ * - Variables: ~/.minion/.env.variables (or DATA_DIR/.env.variables)
+ *
+ * Files use standard .env format: KEY=value (one per line, # for comments).
+ * Secrets never leave the minion; variables are non-sensitive configuration.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { DATA_DIR } = require('../lib/platform')
+const { config } = require('../config')
+
+/**
+ * Resolve file path for a given store type.
+ * @param {'secrets' | 'variables'} type
+ * @returns {string}
+ */
+function getFilePath(type) {
+  const filename = type === 'secrets' ? '.env.secrets' : '.env.variables'
+  try {
+    fs.accessSync(DATA_DIR, fs.constants.W_OK)
+    return path.join(DATA_DIR, filename)
+  } catch {
+    return path.join(config.HOME_DIR, '.minion', filename)
+  }
+}
+
+/**
+ * Parse a .env file into a key-value object.
+ * @param {string} filePath
+ * @returns {Record<string, string>}
+ */
+function parseEnvFile(filePath) {
+  const result = {}
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim()
+      if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) continue
+      const eqIdx = trimmed.indexOf('=')
+      const key = trimmed.slice(0, eqIdx).trim()
+      const value = trimmed.slice(eqIdx + 1).trim()
+      if (key) result[key] = value
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.error(`[VariableStore] Failed to read ${filePath}: ${err.message}`)
+    }
+  }
+  return result
+}
+
+/**
+ * Write a key-value object to a .env file.
+ * @param {string} filePath
+ * @param {Record<string, string>} data
+ */
+function writeEnvFile(filePath, data) {
+  const dir = path.dirname(filePath)
+  fs.mkdirSync(dir, { recursive: true })
+
+  const lines = Object.entries(data).map(([key, value]) => `${key}=${value}`)
+  fs.writeFileSync(filePath, lines.join('\n') + '\n', 'utf-8')
+}
+
+/**
+ * Get all key-value pairs for a store type.
+ * @param {'secrets' | 'variables'} type
+ * @returns {Record<string, string>}
+ */
+function getAll(type) {
+  return parseEnvFile(getFilePath(type))
+}
+
+/**
+ * Get a single value by key.
+ * @param {'secrets' | 'variables'} type
+ * @param {string} key
+ * @returns {string | null}
+ */
+function get(type, key) {
+  const data = getAll(type)
+  return data[key] ?? null
+}
+
+/**
+ * Set a key-value pair (creates or updates).
+ * @param {'secrets' | 'variables'} type
+ * @param {string} key
+ * @param {string} value
+ */
+function set(type, key, value) {
+  const filePath = getFilePath(type)
+  const data = parseEnvFile(filePath)
+  data[key] = value
+  writeEnvFile(filePath, data)
+  console.log(`[VariableStore] Set ${type} key: ${key}`)
+}
+
+/**
+ * Remove a key.
+ * @param {'secrets' | 'variables'} type
+ * @param {string} key
+ * @returns {boolean} true if key existed
+ */
+function remove(type, key) {
+  const filePath = getFilePath(type)
+  const data = parseEnvFile(filePath)
+  if (!(key in data)) return false
+  delete data[key]
+  writeEnvFile(filePath, data)
+  console.log(`[VariableStore] Removed ${type} key: ${key}`)
+  return true
+}
+
+/**
+ * List all keys for a store type.
+ * @param {'secrets' | 'variables'} type
+ * @returns {string[]}
+ */
+function listKeys(type) {
+  return Object.keys(getAll(type))
+}
+
+/**
+ * Build a merged environment object from minion variables and secrets.
+ * Used by workflow/routine runners to inject into execution environment.
+ * Secrets override variables when keys collide.
+ *
+ * @param {Record<string, string>} [extraVars] - Additional variables (e.g. project/workflow vars from HQ)
+ * @returns {Record<string, string>} Merged key-value pairs
+ */
+function buildEnv(extraVars = {}) {
+  const variables = getAll('variables')
+  const secrets = getAll('secrets')
+  // Merge order: variables < secrets < extraVars (later wins)
+  return { ...variables, ...secrets, ...extraVars }
+}
+
+module.exports = {
+  getAll,
+  get,
+  set,
+  remove,
+  listKeys,
+  buildEnv,
+  getFilePath,
+}

package/linux/routes/chat.js

@@ -285,7 +285,8 @@ function streamLlmResponse(res, prompt, sessionId) {
       args.push('--resume', sessionId)
     }
 
-    args.push(prompt)
+    // Prompt is passed via stdin (not as CLI argument) to avoid
+    // shell argument parsing issues with spaces/special characters.
 
     console.log(`[Chat] spawning: ${binary} ${sessionId ? `--resume ${sessionId}` : '(new session)'} (cwd: ${config.HOME_DIR})`)
 
@@ -304,7 +305,8 @@ function streamLlmResponse(res, prompt, sessionId) {
     // Track active child process for abort
     activeChatChild = child
 
-    // Close stdin immediately so CLI doesn't wait for input
+    // Write prompt to stdin and close — claude -p reads from stdin when no positional arg
+    child.stdin.write(prompt)
     child.stdin.end()
 
     console.log(`[Chat] child PID: ${child.pid}`)
@@ -509,7 +511,7 @@ function runQuickLlmCall(prompt) {
       '/bin',
     ].join(':')
 
-    const args = ['-p', '--model', 'haiku', '--max-turns', '1', '--output-format', 'json', prompt]
+    const args = ['-p', '--model', 'haiku', '--max-turns', '1', '--output-format', 'json']
 
     const child = spawn(binary, args, {
       cwd: config.HOME_DIR,
@@ -523,6 +525,7 @@ function runQuickLlmCall(prompt) {
       },
     })
 
+    child.stdin.write(prompt)
     child.stdin.end()
 
     let stdout = ''

package/linux/routine-runner.js

@@ -22,6 +22,7 @@ const { config } = require('../core/config')
 const executionStore = require('../core/stores/execution-store')
 const routineStore = require('../core/stores/routine-store')
 const logManager = require('../core/lib/log-manager')
+const variableStore = require('../core/stores/variable-store')
 
 // Active cron jobs keyed by routine ID
 const activeJobs = new Map()
@@ -155,8 +156,13 @@ async function executeRoutineSession(routine, executionId, skillNames) {
     const llmCommand = config.LLM_COMMAND.replace(/\{prompt\}/g, escapedPrompt)
     const execCommand = `${llmCommand}; echo $? > ${exitCodeFile}`
 
+    // Build injected environment: minion variables/secrets (routines don't receive HQ vars)
+    const injectedEnv = variableStore.buildEnv()
+
     // Create tmux session with extended environment
     // Pass execution context as environment variables for /execution-report skill
+    const tmuxEnvFlags = Object.entries(injectedEnv)
+      .map(([k, v]) => `-e "${k}=${v.replace(/"/g, '\\"')}"`)
     const tmuxCommand = [
       'tmux new-session -d',
       `-s "${sessionName}"`,
@@ -167,6 +173,7 @@ async function executeRoutineSession(routine, executionId, skillNames) {
       `-e "MINION_EXECUTION_ID=${executionId}"`,
       `-e "MINION_ROUTINE_ID=${routine.id}"`,
       `-e "MINION_ROUTINE_NAME=${routine.name.replace(/"/g, '\\"')}"`,
+      ...tmuxEnvFlags,
       `"${execCommand}"`,
     ].join(' ')
 

package/linux/server.js

@@ -16,6 +16,8 @@
  * Directives:           POST /api/directive
  * Auth:                 GET /api/auth/status
  * Chat:                 POST /api/chat, GET /api/chat/session, POST /api/chat/clear
+ * Variables:            GET/PUT/DELETE /api/variables, /api/variables/:key
+ * Secrets:              GET /api/secrets, PUT/DELETE /api/secrets/:key
  * Config:               GET /api/config/backup, GET/PUT /api/config/env
  * Executions:           GET /api/executions, GET /api/executions/:id, etc.
  * ─────────────────────────────────────────────────────────────────────────────
@@ -33,6 +35,7 @@ const PACKAGE_ROOT = path.join(__dirname, '..')
 const { config, validate, isHqConfigured } = require('../core/config')
 const { sendHeartbeat } = require('../core/api')
 const { version } = require('../package.json')
+const { getCapabilities } = require('../core/lib/capability-checker')
 const workflowStore = require('../core/stores/workflow-store')
 const routineStore = require('../core/stores/routine-store')
 
@@ -57,6 +60,7 @@ const { skillRoutes } = require('../core/routes/skills')
 const { workflowRoutes } = require('../core/routes/workflows')
 const { routineRoutes } = require('../core/routes/routines')
 const { authRoutes } = require('../core/routes/auth')
+const { variableRoutes } = require('../core/routes/variables')
 
 // Linux-specific routes
 const { commandRoutes, getProcessManager, getAllowedCommands } = require('./routes/commands')
@@ -89,7 +93,7 @@ async function shutdown(signal) {
   if (isHqConfigured()) {
     try {
       await Promise.race([
-        sendHeartbeat({ status: 'offline', version }),
+        sendHeartbeat({ status: 'offline', version, capabilities: getCapabilities() }),
         new Promise(resolve => setTimeout(resolve, 3000)),
       ])
     } catch {
@@ -252,6 +256,7 @@ async function registerAllRoutes(app) {
   await app.register(workflowRoutes, { workflowRunner })
   await app.register(routineRoutes, { routineRunner })
   await app.register(authRoutes)
+  await app.register(variableRoutes)
 
   // Linux-specific routes
   await app.register(commandRoutes)
@@ -317,14 +322,14 @@ async function start() {
       // Send initial online heartbeat
       const { getStatus } = require('../core/routes/health')
       const { currentTask } = getStatus()
-      sendHeartbeat({ status: 'online', current_task: currentTask, version }).catch(err => {
+      sendHeartbeat({ status: 'online', current_task: currentTask, version, capabilities: getCapabilities() }).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 => {
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, version, capabilities: getCapabilities() }).catch(err => {
           console.error('[Heartbeat] Periodic heartbeat failed:', err.message)
         })
       }, HEARTBEAT_INTERVAL_MS)

package/linux/workflow-runner.js

@@ -20,6 +20,7 @@ const execAsync = promisify(exec)
 const { config } = require('../core/config')
 const executionStore = require('../core/stores/execution-store')
 const workflowStore = require('../core/stores/workflow-store')
+const variableStore = require('../core/stores/variable-store')
 const logManager = require('../core/lib/log-manager')
 
 // Active cron jobs keyed by workflow ID
@@ -117,7 +118,12 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
     const llmCommand = config.LLM_COMMAND.replace(/\{prompt\}/g, escapedPrompt)
     const execCommand = `${llmCommand}; echo $? > ${exitCodeFile}`
 
+    // Build injected environment: minion variables/secrets + extra vars from HQ
+    const injectedEnv = variableStore.buildEnv(options.extraEnv || {})
+
     // Create tmux session with extended environment
+    const tmuxEnvFlags = Object.entries(injectedEnv)
+      .map(([k, v]) => `-e "${k}=${v.replace(/"/g, '\\"')}"`)
     const tmuxCommand = [
       'tmux new-session -d',
       `-s "${sessionName}"`,
@@ -125,6 +131,7 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
       `-e "DISPLAY=:99"`,
       `-e "PATH=${extendedPath}"`,
       `-e "HOME=${homeDir}"`,
+      ...tmuxEnvFlags,
       `"${execCommand}"`,
     ].join(' ')
 

package/package.json

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

package/win/routes/chat.js

@@ -218,7 +218,8 @@ function streamLlmResponse(res, prompt, sessionId) {
 
     const args = ['-p', '--verbose', '--model', 'sonnet', '--output-format', 'stream-json']
     if (sessionId) args.push('--resume', sessionId)
-    args.push(prompt)
+    // Prompt is passed via stdin (not as CLI argument) to avoid
+    // shell argument parsing issues with spaces/special characters.
 
     console.log(`[Chat] spawning: ${binary} ${sessionId ? `--resume ${sessionId}` : '(new session)'}`)
 
@@ -236,6 +237,8 @@ function streamLlmResponse(res, prompt, sessionId) {
     })
 
     activeChatChild = child
+    // Write prompt to stdin and close — claude -p reads from stdin when no positional arg
+    child.stdin.write(prompt)
     child.stdin.end()
 
     console.log(`[Chat] child PID: ${child.pid}`)
@@ -401,7 +404,7 @@ function runQuickLlmCall(prompt) {
     const binary = fs.existsSync(binaryPath) ? binaryPath : binaryName
     const extendedPath = buildExtendedPath(config.HOME_DIR)
 
-    const args = ['-p', '--model', 'haiku', '--max-turns', '1', '--output-format', 'json', prompt]
+    const args = ['-p', '--model', 'haiku', '--max-turns', '1', '--output-format', 'json']
 
     const child = spawn(binary, args, {
       cwd: config.HOME_DIR,
@@ -416,6 +419,7 @@ function runQuickLlmCall(prompt) {
       },
     })
 
+    child.stdin.write(prompt)
     child.stdin.end()
 
     let stdout = ''

package/win/routine-runner.js

@@ -17,6 +17,7 @@ const executionStore = require('../core/stores/execution-store')
 const routineStore = require('../core/stores/routine-store')
 const logManager = require('../core/lib/log-manager')
 const { MARKER_DIR, buildExtendedPath } = require('../core/lib/platform')
+const variableStore = require('../core/stores/variable-store')
 const { activeSessions } = require('./workflow-runner')
 
 const activeJobs = new Map()
@@ -105,8 +106,11 @@ async function executeRoutineSession(routine, executionId, skillNames) {
     const escapedPrompt = prompt.replace(/'/g, "''")
     const llmCommand = config.LLM_COMMAND.replace(/\{prompt\}/g, escapedPrompt)
 
+    // Inject minion variables/secrets (routines don't receive HQ vars)
+    const injectedEnv = variableStore.buildEnv()
     const env = {
       ...process.env,
+      ...injectedEnv,
       HOME: homeDir,
       USERPROFILE: homeDir,
       PATH: extendedPath,

package/win/server.js

@@ -16,6 +16,7 @@ const fastify = require('fastify')({ logger: true })
 const { config, validate, isHqConfigured } = require('../core/config')
 const { sendHeartbeat } = require('../core/api')
 const { version } = require('../package.json')
+const { getCapabilities } = require('../core/lib/capability-checker')
 const workflowStore = require('../core/stores/workflow-store')
 const routineStore = require('../core/stores/routine-store')
 
@@ -45,6 +46,7 @@ const { skillRoutes } = require('../core/routes/skills')
 const { workflowRoutes } = require('../core/routes/workflows')
 const { routineRoutes } = require('../core/routes/routines')
 const { authRoutes } = require('../core/routes/auth')
+const { variableRoutes } = require('../core/routes/variables')
 
 // Validate configuration
 validate()
@@ -69,7 +71,7 @@ async function shutdown(signal) {
   if (isHqConfigured()) {
     try {
       await Promise.race([
-        sendHeartbeat({ status: 'offline', version }),
+        sendHeartbeat({ status: 'offline', version, capabilities: getCapabilities() }),
         new Promise(resolve => setTimeout(resolve, 3000)),
       ])
     } catch {
@@ -192,6 +194,7 @@ async function registerRoutes(app) {
   await app.register(workflowRoutes, { workflowRunner })
   await app.register(routineRoutes, { routineRunner })
   await app.register(authRoutes)
+  await app.register(variableRoutes)
 
   // Windows-specific routes
   await app.register(commandRoutes)
@@ -255,14 +258,14 @@ async function start() {
       // Send initial online heartbeat
       const { getStatus } = require('../core/routes/health')
       const { currentTask } = getStatus()
-      sendHeartbeat({ status: 'online', current_task: currentTask, version }).catch(err => {
+      sendHeartbeat({ status: 'online', current_task: currentTask, version, capabilities: getCapabilities() }).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 => {
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, version, capabilities: getCapabilities() }).catch(err => {
           console.error('[Heartbeat] Periodic heartbeat failed:', err.message)
         })
       }, HEARTBEAT_INTERVAL_MS)

package/win/workflow-runner.js

@@ -24,6 +24,7 @@ const executionStore = require('../core/stores/execution-store')
 const workflowStore = require('../core/stores/workflow-store')
 const logManager = require('../core/lib/log-manager')
 const { buildExtendedPath } = require('../core/lib/platform')
+const variableStore = require('../core/stores/variable-store')
 
 // Active cron jobs keyed by workflow ID
 const activeJobs = new Map()
@@ -112,9 +113,11 @@ async function executeWorkflowSession(workflow, executionId, skillNames, options
     const escapedPrompt = prompt.replace(/'/g, "''")
     const llmCommand = config.LLM_COMMAND.replace(/\{prompt\}/g, escapedPrompt)
 
-    // Build environment
+    // Build environment: base + minion variables/secrets + extra vars from HQ
+    const injectedEnv = variableStore.buildEnv(options.extraEnv || {})
     const env = {
       ...process.env,
+      ...injectedEnv,
       HOME: homeDir,
       USERPROFILE: homeDir,
       PATH: extendedPath,