@geekbeer/minion 3.6.4 → 3.8.0

package/core/db.js

@@ -241,6 +241,60 @@ function initSchema(db) {
 
     CREATE INDEX IF NOT EXISTS idx_workflows_name ON workflows(name);
 
+    -- ==================== todos ====================
+    CREATE TABLE IF NOT EXISTS todos (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL DEFAULT 'pending'
+        CHECK (status IN ('pending', 'in_progress', 'done', 'cancelled')),
+      priority TEXT NOT NULL DEFAULT 'normal'
+        CHECK (priority IN ('low', 'normal', 'high', 'urgent')),
+      source_type TEXT
+        CHECK (source_type IS NULL OR source_type IN ('thread', 'workflow', 'directive', 'user', 'self')),
+      source_id TEXT,
+      project_id TEXT,
+      due_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT,
+      data TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_todos_status ON todos(status);
+    CREATE INDEX IF NOT EXISTS idx_todos_project ON todos(project_id);
+    CREATE INDEX IF NOT EXISTS idx_todos_priority ON todos(priority);
+
+    -- ==================== emails ====================
+    CREATE TABLE IF NOT EXISTS emails (
+      id TEXT PRIMARY KEY,
+      from_address TEXT NOT NULL,
+      to_address TEXT NOT NULL,
+      subject TEXT DEFAULT '',
+      body_text TEXT DEFAULT '',
+      body_html TEXT DEFAULT '',
+      received_at TEXT NOT NULL,
+      is_read INTEGER DEFAULT 0,
+      labels TEXT DEFAULT '[]'
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_emails_received_at ON emails(received_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_emails_from ON emails(from_address);
+    CREATE INDEX IF NOT EXISTS idx_emails_is_read ON emails(is_read);
+
+    -- ==================== email_attachments ====================
+    CREATE TABLE IF NOT EXISTS email_attachments (
+      id TEXT PRIMARY KEY,
+      email_id TEXT NOT NULL REFERENCES emails(id) ON DELETE CASCADE,
+      filename TEXT NOT NULL,
+      content_type TEXT,
+      size_bytes INTEGER DEFAULT 0,
+      approved INTEGER DEFAULT 0,
+      data BLOB
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_email_attachments_email ON email_attachments(email_id);
+
     -- ==================== schema_version ====================
     CREATE TABLE IF NOT EXISTS schema_version (
       version INTEGER PRIMARY KEY,
@@ -334,6 +388,43 @@ function migrateSchema(db) {
 
     console.log('[DB] Migration 1 complete: FTS5 trigram tokenizer applied')
   }
+
+  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;
+
+      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')
+  }
 }
 
 /**

package/core/lib/running-tasks.js

@@ -55,10 +55,18 @@ function pushToHQ() {
     debounceTimer = null
     try {
       const { currentStatus, currentTask } = getStatusFn()
+
+      // Include todo summary if store is available
+      let todo_summary = null
+      try {
+        todo_summary = require('../stores/todo-store').getSummary()
+      } catch { /* store not yet initialized */ }
+
       getSendHeartbeat()({
         status: currentStatus,
         current_task: currentTask,
         running_tasks: tasks,
+        todo_summary,
         version: getVersion(),
       }).catch(err => {
         console.error('[RunningTasks] Heartbeat push failed:', err.message)

package/core/lib/thread-watcher.js

@@ -240,7 +240,8 @@ ${messageHistory || '(メッセージなし)'}
 {
   "should_respond": true/false,
   "reason": "判断の理由（1行）",
-  "response": "返信内容（should_respondがtrueの場合のみ）"
+  "response": "返信内容（should_respondがtrueの場合のみ）",
+  "todo": { "title": "タスク名", "priority": "normal|high|urgent", "due_at": "YYYY-MM-DD" }
 }
 
 判断基準:
@@ -249,7 +250,8 @@ ${messageHistory || '(メッセージなし)'}
 ${isWorkspace ? '- ワークスペーススレッドではすべてのミニオンが参加可能。自分が貢献できる場合は積極的に参加する' : `- 自分のロール（${myProject.role}）に関連する話題か`}
 - 自分が貢献できる知見や意見があるか
 - 既に十分な回答がある場合は重複を避ける
-- 人間に聞くべき場合は @user メンションを含めて返信する`
+- 人間に聞くべき場合は @user メンションを含めて返信する
+- あなたが具体的なアクション（調査、修正、確認など）を引き受ける場合は、todoフィールドにタスクを記録する（オプション。単なる情報提供や質問への回答では不要）`
 
   try {
     const result = await llmCallFn(prompt)
@@ -282,6 +284,24 @@ ${isWorkspace ? '- ワークスペーススレッドではすべてのミニオ
     } else {
       console.log(`[ThreadWatcher] Skipped thread "${threadDetail.title}" (reason: ${parsed.reason || 'not relevant'})`)
     }
+
+    // Auto-create TODO if LLM detected a commitment
+    if (parsed.todo && parsed.todo.title) {
+      try {
+        const todoStore = require('../stores/todo-store')
+        todoStore.add({
+          title: parsed.todo.title,
+          priority: parsed.todo.priority || 'normal',
+          due_at: parsed.todo.due_at || null,
+          source_type: 'thread',
+          source_id: threadSummary.id,
+          project_id: threadSummary.project_id || null,
+        })
+        console.log(`[ThreadWatcher] Created TODO from thread: "${parsed.todo.title}"`)
+      } catch (err) {
+        console.error(`[ThreadWatcher] Failed to create TODO: ${err.message}`)
+      }
+    }
   } catch (err) {
     console.error(`[ThreadWatcher] LLM evaluation failed for thread ${threadSummary.id}: ${err.message}`)
   }

package/core/routes/diagnose.js

@@ -159,16 +159,19 @@ function checkVnc() {
     }
   }
 
-  // Linux: Xvfb + x11vnc + websockify (noVNC)
+  // Linux: Xvfb + VNC server (x0vncserver or x11vnc) + websockify (noVNC)
   const xvfb = isProcessRunning('Xvfb')
-  const vnc = isProcessRunning('x11vnc')
+  const x0vnc = isProcessRunning('x0vncserver') || isProcessRunning('X0tigervnc')
+  const x11vnc = isProcessRunning('x11vnc')
+  const vncServer = x0vnc || x11vnc
+  const vncBackend = isPortListening(5900)
   const websockify = isPortListening(6080)
   return {
-    running: xvfb && websockify,
+    running: xvfb && vncBackend && websockify,
     details: [
-      `Xvfb: ${xvfb ? 'running' : 'not running'}`,
-      `x11vnc: ${vnc ? 'running' : 'not running'}`,
-      `websockify (:6080): ${websockify ? 'listening' : 'not listening'}`,
+      `Xvfb: ${xvfb ? 'running' : 'NOT RUNNING'}`,
+      `VNC server (:5900): ${vncServer ? 'running' : 'NOT RUNNING'}${vncBackend ? '' : ' (port not listening)'}`,
+      `websockify (:6080): ${websockify ? 'listening' : 'NOT LISTENING'}`,
     ].join(', '),
   }
 }

package/core/routes/emails.js

@@ -0,0 +1,188 @@
+/**
+ * Email management endpoints
+ *
+ * Provides inbox API for the minion's local email storage.
+ * Emails are received from Cloudflare Email Worker (POST) and
+ * read by Claude Code or HQ dashboard (GET).
+ *
+ * Endpoints:
+ *   POST   /api/email/inbox                                    - Receive email from Worker
+ *   GET    /api/email/inbox                                    - List emails (with filters)
+ *   GET    /api/email/inbox/summary                            - Unread/total counts
+ *   GET    /api/email/inbox/:id                                - Get single email
+ *   PUT    /api/email/inbox/:id                                - Update (read/unread/labels)
+ *   DELETE /api/email/inbox/:id                                - Delete email
+ *   POST   /api/email/inbox/:id/attachments/:attachmentId/approve - Approve attachment
+ *   GET    /api/email/inbox/:id/attachments/:attachmentId         - Get attachment
+ */
+
+const { verifyToken } = require('../lib/auth')
+const emailStore = require('../stores/email-store')
+
+/**
+ * Register email routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function emailRoutes(fastify) {
+
+  // GET /api/email/inbox/summary - Unread/total counts (must be before /:id)
+  fastify.get('/api/email/inbox/summary', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const summary = emailStore.getSummary()
+    return { success: true, summary }
+  })
+
+  // GET /api/email/inbox - List emails with optional filters
+  fastify.get('/api/email/inbox', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { is_read, from_address, search, limit } = request.query || {}
+    const emails = emailStore.list({
+      is_read,
+      from_address,
+      search,
+      limit: limit ? parseInt(limit, 10) : undefined,
+    })
+
+    return { success: true, emails }
+  })
+
+  // GET /api/email/inbox/:id - Get single email
+  fastify.get('/api/email/inbox/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const email = emailStore.getById(request.params.id)
+    if (!email) {
+      reply.code(404)
+      return { success: false, error: 'Email not found' }
+    }
+
+    return { success: true, email }
+  })
+
+  // POST /api/email/inbox - Receive email from Cloudflare Email Worker
+  fastify.post('/api/email/inbox', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { from_address, to_address, subject, body_text, body_html, labels, attachments } = request.body || {}
+    if (!from_address || !to_address) {
+      reply.code(400)
+      return { success: false, error: 'from_address and to_address are required' }
+    }
+
+    try {
+      const email = emailStore.add({ from_address, to_address, subject, body_text, body_html, labels, attachments })
+      console.log(`[Emails] Received: "${email.subject}" from ${email.from_address}`)
+      reply.code(201)
+      return { success: true, email }
+    } catch (err) {
+      reply.code(400)
+      return { success: false, error: err.message }
+    }
+  })
+
+  // PUT /api/email/inbox/:id - Update email (read/unread, labels)
+  fastify.put('/api/email/inbox/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { is_read } = request.body || {}
+    const id = request.params.id
+
+    if (is_read === 1 || is_read === true) {
+      const updated = emailStore.markAsRead(id)
+      if (!updated) {
+        reply.code(404)
+        return { success: false, error: 'Email not found' }
+      }
+    } else if (is_read === 0 || is_read === false) {
+      const updated = emailStore.markAsUnread(id)
+      if (!updated) {
+        reply.code(404)
+        return { success: false, error: 'Email not found' }
+      }
+    }
+
+    const email = emailStore.getById(id)
+    if (!email) {
+      reply.code(404)
+      return { success: false, error: 'Email not found' }
+    }
+
+    return { success: true, email }
+  })
+
+  // DELETE /api/email/inbox/:id - Delete email
+  fastify.delete('/api/email/inbox/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const deleted = emailStore.remove(request.params.id)
+    if (!deleted) {
+      reply.code(404)
+      return { success: false, error: 'Email not found' }
+    }
+
+    console.log(`[Emails] Deleted: ${request.params.id}`)
+    return { success: true }
+  })
+
+  // POST /api/email/inbox/:id/attachments/:attachmentId/approve - Approve attachment
+  fastify.post('/api/email/inbox/:id/attachments/:attachmentId/approve', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const approved = emailStore.approveAttachment(request.params.attachmentId)
+    if (!approved) {
+      reply.code(404)
+      return { success: false, error: 'Attachment not found' }
+    }
+
+    console.log(`[Emails] Attachment approved: ${request.params.attachmentId}`)
+    return { success: true }
+  })
+
+  // GET /api/email/inbox/:id/attachments/:attachmentId - Get attachment
+  fastify.get('/api/email/inbox/:id/attachments/:attachmentId', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const attachment = emailStore.getAttachment(request.params.attachmentId)
+    if (!attachment) {
+      reply.code(404)
+      return { success: false, error: 'Attachment not found' }
+    }
+
+    if (!attachment.approved) {
+      return { success: true, attachment: { id: attachment.id, filename: attachment.filename, content_type: attachment.content_type, size_bytes: attachment.size_bytes, approved: false } }
+    }
+
+    // Return binary data with correct content type
+    reply.header('Content-Type', attachment.content_type || 'application/octet-stream')
+    reply.header('Content-Disposition', `attachment; filename="${attachment.filename}"`)
+    return reply.send(attachment.data)
+  })
+}
+
+module.exports = { emailRoutes }

package/core/routes/todos.js

@@ -0,0 +1,135 @@
+/**
+ * TODO management endpoints
+ *
+ * Provides CRUD for the minion's local TODO list.
+ * TODOs are stored in SQLite and synced to HQ via heartbeat summary.
+ *
+ * Endpoints:
+ *   GET    /api/todos           - List todos (with optional filters)
+ *   GET    /api/todos/summary   - Get status counts
+ *   GET    /api/todos/:id       - Get a single todo
+ *   POST   /api/todos           - Create a new todo
+ *   PUT    /api/todos/:id       - Update a todo
+ *   DELETE /api/todos/:id       - Delete a todo
+ */
+
+const { verifyToken } = require('../lib/auth')
+const todoStore = require('../stores/todo-store')
+
+/**
+ * Register todo routes as Fastify plugin
+ * @param {import('fastify').FastifyInstance} fastify
+ */
+async function todoRoutes(fastify) {
+
+  // GET /api/todos/summary - Status counts (must be before /:id)
+  fastify.get('/api/todos/summary', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const summary = todoStore.getSummary()
+    return { success: true, summary }
+  })
+
+  // GET /api/todos - List with optional filters
+  fastify.get('/api/todos', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { status, priority, project_id, source_type, limit } = request.query || {}
+    const todos = todoStore.list({
+      status,
+      priority,
+      project_id,
+      source_type,
+      limit: limit ? parseInt(limit, 10) : undefined,
+    })
+
+    return { success: true, todos }
+  })
+
+  // GET /api/todos/:id - Get single todo
+  fastify.get('/api/todos/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const todo = todoStore.getById(request.params.id)
+    if (!todo) {
+      reply.code(404)
+      return { success: false, error: 'Todo not found' }
+    }
+
+    return { success: true, todo }
+  })
+
+  // POST /api/todos - Create a new todo
+  fastify.post('/api/todos', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const { title, description, priority, source_type, source_id, project_id, due_at, data } = request.body || {}
+    if (!title) {
+      reply.code(400)
+      return { success: false, error: 'title is required' }
+    }
+
+    try {
+      const todo = todoStore.add({ title, description, priority, source_type, source_id, project_id, due_at, data })
+      console.log(`[Todos] Created: ${todo.id} "${todo.title}"`)
+      reply.code(201)
+      return { success: true, todo }
+    } catch (err) {
+      reply.code(400)
+      return { success: false, error: err.message }
+    }
+  })
+
+  // PUT /api/todos/:id - Update a todo
+  fastify.put('/api/todos/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    try {
+      const todo = todoStore.update(request.params.id, request.body || {})
+      if (!todo) {
+        reply.code(404)
+        return { success: false, error: 'Todo not found' }
+      }
+
+      console.log(`[Todos] Updated: ${todo.id} → ${todo.status}`)
+      return { success: true, todo }
+    } catch (err) {
+      reply.code(400)
+      return { success: false, error: err.message }
+    }
+  })
+
+  // DELETE /api/todos/:id - Delete a todo
+  fastify.delete('/api/todos/:id', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const deleted = todoStore.remove(request.params.id)
+    if (!deleted) {
+      reply.code(404)
+      return { success: false, error: 'Todo not found' }
+    }
+
+    console.log(`[Todos] Deleted: ${request.params.id}`)
+    return { success: true }
+  })
+}
+
+module.exports = { todoRoutes }

package/core/stores/email-store.js

@@ -0,0 +1,274 @@
+/**
+ * Email Store (SQLite)
+ * Persists received emails to local SQLite database.
+ * Emails are received from Cloudflare Email Worker via HTTP POST.
+ *
+ * Attachments are stored separately with an approval gate:
+ * - approved=0: attachment metadata only, data accessible but not served to Claude Code
+ * - approved=1: attachment approved by human via HQ dashboard
+ */
+
+const crypto = require('crypto')
+const { getDb } = require('../db')
+
+// Auto-prune read emails older than this
+const PRUNE_DAYS = 90
+
+/**
+ * Store a received email.
+ * @param {object} email - { from_address, to_address, subject?, body_text?, body_html?, labels?, attachments? }
+ * @returns {object} Created email record
+ */
+function add(email) {
+  const db = getDb()
+
+  if (!email.from_address || !email.to_address) {
+    throw new Error('from_address and to_address are required')
+  }
+
+  const id = crypto.randomBytes(6).toString('hex')
+  const now = new Date().toISOString()
+
+  const record = {
+    id,
+    from_address: email.from_address,
+    to_address: email.to_address,
+    subject: email.subject || '',
+    body_text: email.body_text || '',
+    body_html: email.body_html || '',
+    received_at: email.received_at || now,
+    is_read: 0,
+    labels: JSON.stringify(email.labels || []),
+  }
+
+  const insertEmail = db.prepare(`
+    INSERT INTO emails (id, from_address, to_address, subject, body_text, body_html, received_at, is_read, labels)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `)
+
+  const insertAttachment = db.prepare(`
+    INSERT INTO email_attachments (id, email_id, filename, content_type, size_bytes, approved, data)
+    VALUES (?, ?, ?, ?, ?, 0, ?)
+  `)
+
+  const tx = db.transaction(() => {
+    insertEmail.run(
+      record.id,
+      record.from_address,
+      record.to_address,
+      record.subject,
+      record.body_text,
+      record.body_html,
+      record.received_at,
+      record.is_read,
+      record.labels
+    )
+
+    if (email.attachments && Array.isArray(email.attachments)) {
+      for (const att of email.attachments) {
+        const attId = crypto.randomBytes(6).toString('hex')
+        const data = att.data ? Buffer.from(att.data, 'base64') : null
+        insertAttachment.run(
+          attId,
+          record.id,
+          att.filename || 'unnamed',
+          att.content_type || 'application/octet-stream',
+          data ? data.length : 0,
+          data
+        )
+      }
+    }
+  })
+
+  tx()
+
+  console.log(`[EmailStore] Received: "${record.subject}" from ${record.from_address}`)
+
+  // Auto-prune old read emails
+  pruneOld()
+
+  return { ...record, labels: email.labels || [] }
+}
+
+/**
+ * Get a single email by ID (with attachment metadata, without attachment data).
+ * @param {string} id
+ * @returns {object|null}
+ */
+function getById(id) {
+  const db = getDb()
+  const row = db.prepare('SELECT * FROM emails WHERE id = ?').get(id)
+  if (!row) return null
+
+  const attachments = db.prepare(
+    'SELECT id, email_id, filename, content_type, size_bytes, approved FROM email_attachments WHERE email_id = ?'
+  ).all(id)
+
+  return { ...parseRow(row), attachments }
+}
+
+/**
+ * List emails with optional filters.
+ * @param {object} opts - { is_read?, from_address?, search?, limit? }
+ * @returns {Array}
+ */
+function list(opts = {}) {
+  const db = getDb()
+  const conditions = []
+  const params = []
+
+  if (opts.is_read !== undefined && opts.is_read !== '') {
+    conditions.push('is_read = ?')
+    params.push(Number(opts.is_read))
+  }
+  if (opts.from_address) {
+    conditions.push('from_address LIKE ?')
+    params.push(`%${opts.from_address}%`)
+  }
+
+  // FTS5 search (trigram requires 3+ chars)
+  if (opts.search && opts.search.length >= 3) {
+    conditions.push('rowid IN (SELECT rowid FROM emails_fts WHERE emails_fts MATCH ?)')
+    params.push(`"${opts.search.replace(/"/g, '""')}"`)
+  } else if (opts.search && opts.search.length > 0) {
+    conditions.push('(subject LIKE ? OR body_text LIKE ?)')
+    params.push(`%${opts.search}%`, `%${opts.search}%`)
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''
+  const limit = opts.limit || 50
+
+  const rows = db.prepare(`
+    SELECT * FROM emails ${where}
+    ORDER BY received_at DESC
+    LIMIT ?
+  `).all(...params, limit)
+
+  return rows.map(parseRow)
+}
+
+/**
+ * Mark an email as read.
+ * @param {string} id
+ * @returns {boolean}
+ */
+function markAsRead(id) {
+  const db = getDb()
+  const result = db.prepare('UPDATE emails SET is_read = 1 WHERE id = ?').run(id)
+  return result.changes > 0
+}
+
+/**
+ * Mark an email as unread.
+ * @param {string} id
+ * @returns {boolean}
+ */
+function markAsUnread(id) {
+  const db = getDb()
+  const result = db.prepare('UPDATE emails SET is_read = 0 WHERE id = ?').run(id)
+  return result.changes > 0
+}
+
+/**
+ * Delete an email and its attachments (CASCADE).
+ * @param {string} id
+ * @returns {boolean}
+ */
+function remove(id) {
+  const db = getDb()
+  const result = db.prepare('DELETE FROM emails WHERE id = ?').run(id)
+  const deleted = result.changes > 0
+  if (deleted) console.log(`[EmailStore] Deleted: ${id}`)
+  return deleted
+}
+
+/**
+ * Get email summary (unread count, total count).
+ * @returns {{ unread: number, total: number, latest_at: string|null }}
+ */
+function getSummary() {
+  const db = getDb()
+  const total = db.prepare('SELECT COUNT(*) as cnt FROM emails').get().cnt
+  const unread = db.prepare('SELECT COUNT(*) as cnt FROM emails WHERE is_read = 0').get().cnt
+  const latest = db.prepare('SELECT MAX(received_at) as latest FROM emails').get()
+
+  return { unread, total, latest_at: latest?.latest || null }
+}
+
+/**
+ * Approve an attachment (allow Claude Code to access it).
+ * @param {string} attachmentId
+ * @returns {boolean}
+ */
+function approveAttachment(attachmentId) {
+  const db = getDb()
+  const result = db.prepare('UPDATE email_attachments SET approved = 1 WHERE id = ?').run(attachmentId)
+  if (result.changes > 0) {
+    console.log(`[EmailStore] Attachment approved: ${attachmentId}`)
+  }
+  return result.changes > 0
+}
+
+/**
+ * Get an attachment by ID (returns data only if approved).
+ * @param {string} attachmentId
+ * @param {boolean} requireApproval - If true, only return data for approved attachments
+ * @returns {object|null}
+ */
+function getAttachment(attachmentId, requireApproval = true) {
+  const db = getDb()
+  const row = db.prepare('SELECT * FROM email_attachments WHERE id = ?').get(attachmentId)
+  if (!row) return null
+
+  if (requireApproval && !row.approved) {
+    // Return metadata only, strip data
+    return { id: row.id, email_id: row.email_id, filename: row.filename, content_type: row.content_type, size_bytes: row.size_bytes, approved: row.approved, data: null }
+  }
+
+  return row
+}
+
+/**
+ * Delete old read emails.
+ * @param {number} daysOld
+ */
+function pruneOld(daysOld = PRUNE_DAYS) {
+  const db = getDb()
+  const result = db.prepare(`
+    DELETE FROM emails
+    WHERE is_read = 1
+      AND received_at < datetime('now', ?)
+  `).run(`-${daysOld} days`)
+
+  if (result.changes > 0) {
+    console.log(`[EmailStore] Pruned ${result.changes} read emails older than ${daysOld} days`)
+  }
+}
+
+/**
+ * Parse a database row, deserializing JSON fields.
+ */
+function parseRow(row) {
+  const parsed = { ...row }
+  if (parsed.labels) {
+    try {
+      parsed.labels = JSON.parse(parsed.labels)
+    } catch {
+      parsed.labels = []
+    }
+  }
+  return parsed
+}
+
+module.exports = {
+  add,
+  getById,
+  list,
+  markAsRead,
+  markAsUnread,
+  remove,
+  getSummary,
+  approveAttachment,
+  getAttachment,
+  pruneOld,
+}

package/core/stores/todo-store.js

@@ -0,0 +1,265 @@
+/**
+ * Todo Store (SQLite)
+ * Persists TODO items to local SQLite database.
+ * Single source of truth for minion's task queue.
+ *
+ * TODOs are created from:
+ * - Thread conversations (LLM detects commitments)
+ * - HQ dashboard / API (user creates directly)
+ * - Minion self-generated (during workflows/chat)
+ */
+
+const crypto = require('crypto')
+const { getDb } = require('../db')
+
+const VALID_STATUSES = ['pending', 'in_progress', 'done', 'cancelled']
+const VALID_PRIORITIES = ['low', 'normal', 'high', 'urgent']
+const VALID_SOURCE_TYPES = ['thread', 'workflow', 'directive', 'user', 'self']
+
+// Auto-prune completed todos older than this
+const PRUNE_DAYS = 30
+
+/**
+ * Create a new TODO.
+ * @param {object} todo - { title, description?, priority?, source_type?, source_id?, project_id?, due_at?, data? }
+ * @returns {object} Created todo with generated ID
+ */
+function add(todo) {
+  const db = getDb()
+
+  if (!todo.title) {
+    throw new Error('title is required')
+  }
+
+  const id = crypto.randomBytes(6).toString('hex')
+  const now = new Date().toISOString()
+  const status = todo.status && VALID_STATUSES.includes(todo.status) ? todo.status : 'pending'
+  const priority = todo.priority && VALID_PRIORITIES.includes(todo.priority) ? todo.priority : 'normal'
+  const source_type = todo.source_type && VALID_SOURCE_TYPES.includes(todo.source_type) ? todo.source_type : null
+
+  const record = {
+    id,
+    title: todo.title,
+    description: todo.description || null,
+    status,
+    priority,
+    source_type,
+    source_id: todo.source_id || null,
+    project_id: todo.project_id || null,
+    due_at: todo.due_at || null,
+    created_at: now,
+    updated_at: now,
+    completed_at: null,
+    ...(todo.data ? { data: todo.data } : {}),
+  }
+
+  db.prepare(`
+    INSERT INTO todos (id, title, description, status, priority, source_type, source_id, project_id, due_at, created_at, updated_at, completed_at, data)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    record.id,
+    record.title,
+    record.description,
+    record.status,
+    record.priority,
+    record.source_type,
+    record.source_id,
+    record.project_id,
+    record.due_at,
+    record.created_at,
+    record.updated_at,
+    record.completed_at,
+    record.data ? JSON.stringify(record.data) : null
+  )
+
+  console.log(`[TodoStore] Added: "${record.title}" (${record.priority}, source=${record.source_type || 'none'})`)
+
+  // Auto-prune old completed todos
+  pruneCompleted()
+
+  return record
+}
+
+/**
+ * Update an existing TODO.
+ * @param {string} id - Todo ID
+ * @param {object} updates - Fields to update
+ * @returns {object|null} Updated todo or null if not found
+ */
+function update(id, updates) {
+  const db = getDb()
+  const existing = getById(id)
+  if (!existing) return null
+
+  const now = new Date().toISOString()
+
+  // Validate enum fields if provided
+  if (updates.status && !VALID_STATUSES.includes(updates.status)) {
+    throw new Error(`Invalid status: ${updates.status}`)
+  }
+  if (updates.priority && !VALID_PRIORITIES.includes(updates.priority)) {
+    throw new Error(`Invalid priority: ${updates.priority}`)
+  }
+
+  const merged = { ...existing, ...updates, updated_at: now }
+
+  // Set completed_at when transitioning to done/cancelled
+  if ((updates.status === 'done' || updates.status === 'cancelled') && !existing.completed_at) {
+    merged.completed_at = now
+  }
+  // Clear completed_at if moving back to active status
+  if ((updates.status === 'pending' || updates.status === 'in_progress') && existing.completed_at) {
+    merged.completed_at = null
+  }
+
+  db.prepare(`
+    UPDATE todos SET title = ?, description = ?, status = ?, priority = ?,
+      source_type = ?, source_id = ?, project_id = ?, due_at = ?,
+      updated_at = ?, completed_at = ?, data = ?
+    WHERE id = ?
+  `).run(
+    merged.title,
+    merged.description,
+    merged.status,
+    merged.priority,
+    merged.source_type,
+    merged.source_id,
+    merged.project_id,
+    merged.due_at,
+    merged.updated_at,
+    merged.completed_at,
+    merged.data ? JSON.stringify(merged.data) : null,
+    id
+  )
+
+  console.log(`[TodoStore] Updated: ${id} → ${merged.status}`)
+  return merged
+}
+
+/**
+ * Remove a TODO by ID.
+ * @param {string} id
+ * @returns {boolean} True if deleted
+ */
+function remove(id) {
+  const db = getDb()
+  const result = db.prepare('DELETE FROM todos WHERE id = ?').run(id)
+  const deleted = result.changes > 0
+  if (deleted) console.log(`[TodoStore] Removed: ${id}`)
+  return deleted
+}
+
+/**
+ * Get a single TODO by ID.
+ * @param {string} id
+ * @returns {object|null}
+ */
+function getById(id) {
+  const db = getDb()
+  const row = db.prepare('SELECT * FROM todos WHERE id = ?').get(id)
+  return row ? parseRow(row) : null
+}
+
+/**
+ * List TODOs with optional filters.
+ * @param {object} opts - { status?, priority?, project_id?, source_type?, limit? }
+ * @returns {Array}
+ */
+function list(opts = {}) {
+  const db = getDb()
+  const conditions = []
+  const params = []
+
+  if (opts.status) {
+    conditions.push('status = ?')
+    params.push(opts.status)
+  }
+  if (opts.priority) {
+    conditions.push('priority = ?')
+    params.push(opts.priority)
+  }
+  if (opts.project_id) {
+    conditions.push('project_id = ?')
+    params.push(opts.project_id)
+  }
+  if (opts.source_type) {
+    conditions.push('source_type = ?')
+    params.push(opts.source_type)
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''
+  const limit = opts.limit || 100
+
+  const rows = db.prepare(`
+    SELECT * FROM todos ${where}
+    ORDER BY
+      CASE priority WHEN 'urgent' THEN 0 WHEN 'high' THEN 1 WHEN 'normal' THEN 2 WHEN 'low' THEN 3 END,
+      created_at DESC
+    LIMIT ?
+  `).all(...params, limit)
+
+  return rows.map(parseRow)
+}
+
+/**
+ * Get summary counts by status.
+ * @returns {{ pending: number, in_progress: number, done: number, cancelled: number, updated_at: string|null }}
+ */
+function getSummary() {
+  const db = getDb()
+  const rows = db.prepare('SELECT status, COUNT(*) as cnt FROM todos GROUP BY status').all()
+  const summary = { pending: 0, in_progress: 0, done: 0, cancelled: 0 }
+  for (const row of rows) {
+    if (summary.hasOwnProperty(row.status)) {
+      summary[row.status] = row.cnt
+    }
+  }
+
+  const latest = db.prepare('SELECT MAX(updated_at) as latest FROM todos').get()
+  summary.updated_at = latest?.latest || null
+
+  return summary
+}
+
+/**
+ * Delete completed/cancelled todos older than the specified number of days.
+ * @param {number} daysOld - Days after completion to prune (default 30)
+ */
+function pruneCompleted(daysOld = PRUNE_DAYS) {
+  const db = getDb()
+  const result = db.prepare(`
+    DELETE FROM todos
+    WHERE status IN ('done', 'cancelled')
+      AND completed_at IS NOT NULL
+      AND completed_at < datetime('now', ?)
+  `).run(`-${daysOld} days`)
+
+  if (result.changes > 0) {
+    console.log(`[TodoStore] Pruned ${result.changes} completed todos older than ${daysOld} days`)
+  }
+}
+
+/**
+ * Parse a database row, deserializing the data JSON field.
+ */
+function parseRow(row) {
+  const parsed = { ...row }
+  if (parsed.data) {
+    try {
+      parsed.data = JSON.parse(parsed.data)
+    } catch {
+      // Keep as string if not valid JSON
+    }
+  }
+  return parsed
+}
+
+module.exports = {
+  add,
+  update,
+  remove,
+  getById,
+  list,
+  getSummary,
+  pruneCompleted,
+}

package/linux/server.js

@@ -20,6 +20,8 @@
  * 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.
+ * TODOs:                GET/POST /api/todos, GET/PUT/DELETE /api/todos/:id
+ * Emails:               POST /api/email/inbox, GET /api/email/inbox, GET/PUT/DELETE /api/email/inbox/:id
  * Sudoers:              GET /api/sudoers
  * ─────────────────────────────────────────────────────────────────────────────
  */
@@ -74,6 +76,8 @@ const { dailyLogRoutes } = require('../core/routes/daily-logs')
 const { sudoersRoutes } = require('../core/routes/sudoers')
 const { permissionRoutes } = require('../core/routes/permissions')
 const { threadRoutes } = require('../core/routes/threads')
+const { todoRoutes } = require('../core/routes/todos')
+const { emailRoutes } = require('../core/routes/emails')
 const { daemonRoutes } = require('../core/routes/daemons')
 
 // Linux-specific routes
@@ -281,6 +285,8 @@ async function registerAllRoutes(app) {
   await app.register(sudoersRoutes)
   await app.register(permissionRoutes)
   await app.register(threadRoutes)
+  await app.register(todoRoutes)
+  await app.register(emailRoutes)
   await app.register(daemonRoutes, { heartbeatStatus: () => ({ running: !!heartbeatTimer, last_beat_at: lastBeatAt }) })
 
   // Linux-specific routes
@@ -366,14 +372,16 @@ async function start() {
       // Send initial online heartbeat
       const { getStatus } = require('../core/routes/health')
       const { currentTask } = getStatus()
-      sendHeartbeat({ status: 'online', current_task: currentTask, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), version }).catch(err => {
+      const todoStore = require('../core/stores/todo-store')
+      const getTodoSummary = () => { try { return todoStore.getSummary() } catch { return null } }
+      sendHeartbeat({ status: 'online', current_task: currentTask, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), todo_summary: getTodoSummary(), 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, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), version }).then(() => {
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, running_tasks: runningTasks.getAll(), config_warnings: getConfigWarnings(), todo_summary: getTodoSummary(), version }).then(() => {
           lastBeatAt = new Date().toISOString()
         }).catch(err => {
           console.error('[Heartbeat] Periodic heartbeat failed:', err.message)

package/package.json

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

package/win/minion-cli.ps1

@@ -901,10 +901,11 @@ function Invoke-Setup {
         # Register cloudflared as NSSM service (config will be set by 'configure --setup-tunnel')
         Invoke-Nssm stop minion-cloudflared
         Invoke-Nssm remove minion-cloudflared confirm
-        $cfConfigDir = Join-Path $TargetUserProfile '.cloudflared'
-        $cfConfigPath = Join-Path $cfConfigDir 'config.yml'
         Invoke-Nssm install minion-cloudflared $cfExe
-        Invoke-Nssm set minion-cloudflared AppParameters "tunnel run --config `"$cfConfigPath`""
+        # Use "tunnel run" without --config; cloudflared defaults to ~/.cloudflared/config.yml
+        # which resolves correctly via USERPROFILE env var set below.
+        # (NSSM mangles --flag to -flag, so we avoid passing double-dash flags entirely)
+        Invoke-Nssm set minion-cloudflared AppParameters "tunnel run"
         # Set USERPROFILE/HOME so cloudflared resolves ~/.cloudflared/ to the target user's profile
         # (NSSM runs as LocalSystem, whose ~ is C:\Windows\system32\config\systemprofile)
         $cfEnvLines = @(
@@ -1374,9 +1375,8 @@ function Invoke-Configure {
                     if ($cfExe) {
                         $isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
                         if ($isAdmin) {
-                            $cfConfigPath = Join-Path $cfConfigDir 'config.yml'
                             Invoke-Nssm install minion-cloudflared $cfExe
-                            Invoke-Nssm set minion-cloudflared AppParameters "tunnel run --config `"$cfConfigPath`""
+                            Invoke-Nssm set minion-cloudflared AppParameters "tunnel run"
                             # Set USERPROFILE/HOME so cloudflared resolves ~/.cloudflared/ to the target user's profile
                             $cfEnvLines = @(
                                 "USERPROFILE=$TargetUserProfile",

package/win/server.js

@@ -58,6 +58,8 @@ const { memoryRoutes } = require('../core/routes/memory')
 const { dailyLogRoutes } = require('../core/routes/daily-logs')
 const { permissionRoutes } = require('../core/routes/permissions')
 const { threadRoutes } = require('../core/routes/threads')
+const { todoRoutes } = require('../core/routes/todos')
+const { emailRoutes } = require('../core/routes/emails')
 const { daemonRoutes } = require('../core/routes/daemons')
 
 // Validate configuration
@@ -215,6 +217,8 @@ async function registerRoutes(app) {
   await app.register(dailyLogRoutes)
   await app.register(permissionRoutes)
   await app.register(threadRoutes)
+  await app.register(todoRoutes)
+  await app.register(emailRoutes)
   await app.register(daemonRoutes, { heartbeatStatus: () => ({ running: !!heartbeatTimer, last_beat_at: lastBeatAt }) })
 
   // Shutdown endpoint — allows detached restart/update scripts to trigger
@@ -311,14 +315,16 @@ async function start() {
       // Send initial online heartbeat
       const { getStatus } = require('../core/routes/health')
       const { currentTask } = getStatus()
-      sendHeartbeat({ status: 'online', current_task: currentTask, config_warnings: getConfigWarnings(), version }).catch(err => {
+      const todoStore = require('../core/stores/todo-store')
+      const getTodoSummary = () => { try { return todoStore.getSummary() } catch { return null } }
+      sendHeartbeat({ status: 'online', current_task: currentTask, config_warnings: getConfigWarnings(), todo_summary: getTodoSummary(), 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, config_warnings: getConfigWarnings(), version }).then(() => {
+        sendHeartbeat({ status: currentStatus, current_task: currentTask, config_warnings: getConfigWarnings(), todo_summary: getTodoSummary(), version }).then(() => {
           lastBeatAt = new Date().toISOString()
         }).catch(err => {
           console.error('[Heartbeat] Periodic heartbeat failed:', err.message)