@geekbeer/minion 2.44.0 → 2.48.1

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/docs/api-reference.md

@@ -75,6 +75,134 @@ Files are stored in `~/files/`. Max upload size: 50MB.
 | POST | `/api/files/*` | Upload a file (Content-Type: `application/octet-stream`) |
 | DELETE | `/api/files/*` | Delete a file or directory |
 
+### Memory (Long-term Knowledge)
+
+Persistent memory entries stored as markdown files in `$DATA_DIR/memory/`.
+Categories: `user` (user preferences), `feedback` (feedback), `project` (project info), `reference` (references).
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/memory` | List all memory entries (id, title, category, excerpt, timestamps) |
+| GET | `/api/memory/:id` | Get full memory entry |
+| POST | `/api/memory` | Create memory entry. Body: `{title, category, content}` |
+| PUT | `/api/memory/:id` | Update memory entry. Body: `{title?, category?, content?}` |
+| DELETE | `/api/memory/:id` | Delete a memory entry |
+
+POST/PUT body:
+```json
+{
+  "title": "ユーザーはレビューで日本語を好む",
+  "category": "user",
+  "content": "コードレビューのコメントは日本語で記述すること。"
+}
+```
+
+Response (list):
+```json
+{
+  "success": true,
+  "entries": [
+    {
+      "id": "abc123",
+      "title": "...",
+      "category": "user",
+      "excerpt": "...",
+      "created_at": "2026-03-12T09:00:00Z",
+      "updated_at": "2026-03-12T09:00:00Z"
+    }
+  ]
+}
+```
+
+### Daily Logs (Short-term Memory)
+
+Daily conversation summaries stored as `$DATA_DIR/daily-logs/YYYY-MM-DD.md`.
+Generated via end-of-day processing or manual creation.
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/daily-logs` | List all logs (date + size, newest first) |
+| POST | `/api/daily-logs` | Create a daily log. Body: `{date, content}` |
+| GET | `/api/daily-logs/:date` | Get a specific day's log content |
+| PUT | `/api/daily-logs/:date` | Update a daily log. Body: `{content}` |
+| DELETE | `/api/daily-logs/:date` | Delete a specific day's log |
+
+POST body:
+```json
+{
+  "date": "2026-03-12",
+  "content": "## 今日やったこと\n- Feature X を実装\n- Bug Y を修正"
+}
+```
+
+PUT body:
+```json
+{
+  "content": "## 今日やったこと\n- Feature X を実装（更新版）"
+}
+```
+
+Response (list):
+```json
+{
+  "success": true,
+  "logs": [
+    { "date": "2026-03-12", "size": 1234 },
+    { "date": "2026-03-11", "size": 567 }
+  ]
+}
+```
+
+### Chat (End-of-Day Processing)
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/api/chat/end-of-day` | Generate daily log + extract memories from conversation |
+
+Body: `{ "clear_session": false }` (optional, defaults to false)
+
+Response:
+```json
+{
+  "success": true,
+  "daily_log": "2026-03-12",
+  "memory_entries_added": 2
+}
+```
+
+### Self-Reflection Schedule (自己反省時間)
+
+The minion has a built-in daily scheduler that automatically runs end-of-day processing
+(daily log generation + memory extraction + session clear) at a configured time.
+
+Configuration via `PUT /api/config/env`:
+
+| Key | Format | Default | Description |
+|-----|--------|---------|-------------|
+| `REFLECTION_TIME` | `HH:MM` | (disabled) | Daily reflection time (e.g., `"03:00"`) |
+| `TIMEZONE` | IANA tz | `Asia/Tokyo` | Timezone for the schedule |
+
+Example — set reflection at 3:00 AM JST:
+```bash
+curl -X PUT /api/config/env \
+  -H "Authorization: Bearer $TOKEN" \
+  -d '{"key": "REFLECTION_TIME", "value": "03:00"}'
+```
+
+The scheduler starts automatically on server boot if `REFLECTION_TIME` is configured.
+Changes via the config API take effect immediately (no restart required).
+
+### Config
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/api/config/env/:key` | Get env variable value (whitelisted keys only) |
+| PUT | `/api/config/env` | Update env variable. Body: `{key, value}` |
+| GET | `/api/config/backup` | Download config files as tar.gz |
+| POST | `/api/config/restore` | Restore config from tar.gz |
+
+Allowed keys: `LLM_COMMAND`, `REFLECTION_TIME`, `TIMEZONE`
+
 ### Commands
 
 | Method | Endpoint | Description |

package/linux/minion-cli.sh

@@ -321,6 +321,8 @@ do_setup() {
     {
       echo "${TARGET_USER} ALL=(root) NOPASSWD: ${NPM_BIN} install -g @geekbeer/minion@latest"
       echo "${TARGET_USER} ALL=(root) NOPASSWD: ${NPM_BIN} install -g @geekbeer/minion@latest --registry *"
+      echo "${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/apt-get install *"
+      echo "${TARGET_USER} ALL=(root) NOPASSWD: /usr/bin/apt-get remove *"
 
       case "$PROC_MGR" in
         systemd)
@@ -336,6 +338,10 @@ do_setup() {
     } | $SUDO tee "$SUDOERS_FILE" > /dev/null
     $SUDO chmod 440 "$SUDOERS_FILE"
     echo "  -> $SUDOERS_FILE created"
+
+    # Protect nodejs from apt-get remove (minion depends on Node.js runtime)
+    $SUDO apt-mark hold nodejs 2>/dev/null || true
+    echo "  -> nodejs marked as hold (protected from removal)"
   else
     echo "  -> Skipped (running as root)"
   fi

package/linux/routes/chat.js

@@ -8,11 +8,12 @@
  * Requires LLM_COMMAND to be configured in minion.env.
  *
  * Endpoints:
- *   POST   /api/chat          - Send message, get SSE stream
- *   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
+ *   POST   /api/chat              - Send message, get SSE stream
+ *   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
+ *   POST   /api/chat/end-of-day    - Generate daily log + extract memories from conversation
  */
 
 const { spawn } = require('child_process')
@@ -21,6 +22,9 @@ const path = require('path')
 const { verifyToken } = require('../../core/lib/auth')
 const { config } = require('../../core/config')
 const chatStore = require('../../core/stores/chat-store')
+const memoryStore = require('../../core/stores/memory-store')
+const dailyLogStore = require('../../core/stores/daily-log-store')
+const { runEndOfDay } = require('../../core/lib/end-of-day')
 
 /** @type {import('child_process').ChildProcess | null} */
 let activeChatChild = null
@@ -45,10 +49,8 @@ async function chatRoutes(fastify) {
       return { success: false, error: 'message is required' }
     }
 
-    // Build prompt — add context prefix when context is available (new or resumed)
-    const prompt = context
-      ? buildContextPrefix(message, context)
-      : message
+    // 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
@@ -175,16 +177,51 @@ async function chatRoutes(fastify) {
     console.log(`[Chat] session reset with summary (${summary?.length || 0} chars)`)
     return { success: true, summary }
   })
+
+  // POST /api/chat/end-of-day - Generate daily log + extract memories
+  fastify.post('/api/chat/end-of-day', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { clear_session = false } = request.body || {}
+
+    const result = await runEndOfDay({
+      runQuickLlmCall,
+      clearSession: clear_session,
+    })
+
+    return { success: true, ...result }
+  })
 }
 
 /**
  * Build context prefix that tells Claude CLI where the user is on the HQ dashboard
  * and how to fetch details via the `hq` helper command.
+ * On new sessions (no session_id), injects minion memory + recent daily logs.
  * No conversation history injection — Claude CLI handles that via --resume.
  */
-function buildContextPrefix(message, context) {
+async function buildContextPrefix(message, context, sessionId) {
   const parts = []
 
+  // Inject memory + daily logs on new sessions only (not on --resume)
+  if (!sessionId) {
+    try {
+      const memorySnippet = await memoryStore.getContextSnippet(2000)
+      const dailyLogSnippet = await dailyLogStore.getContextSnippet(3, 1500)
+
+      if (memorySnippet) {
+        parts.push('[ミニオンメモリ（長期記憶）]', memorySnippet, '')
+      }
+      if (dailyLogSnippet) {
+        parts.push('[最近のデイリーログ]', dailyLogSnippet, '')
+      }
+    } catch (err) {
+      console.error('[Chat] Failed to load memory/daily-log context:', err.message)
+    }
+  }
+
   if (context) {
     switch (context.type) {
       case 'skill':
@@ -285,7 +322,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 +342,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 +548,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 +562,7 @@ function runQuickLlmCall(prompt) {
       },
     })
 
+    child.stdin.write(prompt)
     child.stdin.end()
 
     let stdout = ''
@@ -548,4 +588,4 @@ function runQuickLlmCall(prompt) {
   })
 }
 
-module.exports = { chatRoutes }
+module.exports = { chatRoutes, runQuickLlmCall }

package/linux/routes/config.js

@@ -15,8 +15,13 @@ const { clearLlmCache } = require('../../core/lib/llm-checker')
 const { config, updateConfig } = require('../../core/config')
 const { resolveEnvFilePath: resolveEnvFilePathFromPlatform } = require('../../core/lib/platform')
 
+const reflectionScheduler = require('../../core/lib/reflection-scheduler')
+
 /** Keys that can be read/written via the config API */
-const ALLOWED_ENV_KEYS = ['LLM_COMMAND']
+const ALLOWED_ENV_KEYS = ['LLM_COMMAND', 'REFLECTION_TIME', 'TIMEZONE']
+
+/** Keys that trigger a reflection scheduler reschedule when changed */
+const REFLECTION_KEYS = ['REFLECTION_TIME', 'TIMEZONE']
 
 const BACKUP_PATHS = [
   '~/.claude',
@@ -234,6 +239,11 @@ function configRoutes(fastify, _opts, done) {
       // Clear LLM cache so health check reflects immediately
       clearLlmCache()
 
+      // Reschedule reflection if relevant key changed
+      if (REFLECTION_KEYS.includes(key)) {
+        reflectionScheduler.reschedule()
+      }
+
       return { success: true, restart_required: false }
     } catch (err) {
       console.error(`[Config] Failed to update ${key} in ${envPath}:`, err.message)

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')
 
@@ -49,6 +52,7 @@ 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')
+const reflectionScheduler = require('../core/lib/reflection-scheduler')
 
 // Shared routes (from core/)
 const { healthRoutes, setOffline } = require('../core/routes/health')
@@ -57,13 +61,16 @@ 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')
+const { memoryRoutes } = require('../core/routes/memory')
+const { dailyLogRoutes } = require('../core/routes/daily-logs')
 
 // Linux-specific routes
 const { commandRoutes, getProcessManager, getAllowedCommands } = require('./routes/commands')
 const { terminalRoutes } = require('./routes/terminal')
 const { fileRoutes } = require('./routes/files')
 const { directiveRoutes } = require('./routes/directives')
-const { chatRoutes } = require('./routes/chat')
+const { chatRoutes, runQuickLlmCall } = require('./routes/chat')
 const { configRoutes } = require('./routes/config')
 
 // Validate configuration before starting
@@ -89,7 +96,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 {
@@ -97,9 +104,10 @@ async function shutdown(signal) {
     }
   }
 
-  // Stop pollers and runners
+  // Stop pollers, runners, and scheduler
   stepPoller.stop()
   revisionWatcher.stop()
+  reflectionScheduler.stop()
   workflowRunner.stopAll()
   routineRunner.stopAll()
 
@@ -252,6 +260,9 @@ async function registerAllRoutes(app) {
   await app.register(workflowRoutes, { workflowRunner })
   await app.register(routineRoutes, { routineRunner })
   await app.register(authRoutes)
+  await app.register(variableRoutes)
+  await app.register(memoryRoutes)
+  await app.register(dailyLogRoutes)
 
   // Linux-specific routes
   await app.register(commandRoutes)
@@ -311,20 +322,23 @@ async function start() {
       console.error('[Server] Failed to load cached routines:', err.message)
     }
 
+    // Start reflection scheduler (self-reflection time)
+    reflectionScheduler.start(runQuickLlmCall)
+
     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 => {
+      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.48.1",
   "description": "AI Agent runtime for Minion - manages status and skill deployment on VPS",
   "main": "linux/server.js",
   "bin": {