@geekbeer/minion 4.4.0 → 4.7.0

package/linux/routes/chat.js

@@ -27,15 +27,15 @@ const todoStore = require('../../core/stores/todo-store')
 const { runEndOfDay } = require('../../core/lib/end-of-day')
 const { DATA_DIR } = require('../../core/lib/platform')
 const { getActivePrimary } = require('../../core/llm-plugins/lib/active')
-
-/** @type {import('child_process').ChildProcess | null} */
-let activeChatChild = null
+const chatRunManager = require('../../core/lib/chat-run-manager')
 
 /**
  * Register chat routes as Fastify plugin
  * @param {import('fastify').FastifyInstance} fastify
  */
 async function chatRoutes(fastify) {
+  // Sweep stale runs from a previous boot and prune old run logs.
+  chatRunManager.init()
 
   // POST /api/chat - Send a message and get streaming response
   fastify.post('/api/chat', async (request, reply) => {
@@ -71,25 +71,66 @@ async function chatRoutes(fastify) {
       console.error('[Chat] failed to persist user message:', err.message)
     }
 
+    // Start a DETACHED run. The LLM is owned by the run manager, not this HTTP
+    // request — if the connection drops the run keeps going. This response is
+    // just a live tail of the run's event log.
+    const runId = chatRunManager.start({
+      sessionId: currentSessionId,
+      pendingSessionId,
+      workspaceId,
+      invoke: buildInvoke(prompt, currentSessionId),
+    })
+
     // Take over response handling from Fastify for SSE streaming
     reply.hijack()
-
-    reply.raw.writeHead(200, {
+    const res = reply.raw
+    res.writeHead(200, {
       'Content-Type': 'text/event-stream',
       'Cache-Control': 'no-cache',
       'Connection': 'keep-alive',
     })
-    reply.raw.flushHeaders()
+    res.flushHeaders()
 
-    try {
-      await streamLlmResponse(reply.raw, prompt, currentSessionId, workspaceId, message, pendingSessionId)
-    } catch (err) {
-      console.error('[Chat] stream error:', err.message)
-      const errorEvent = JSON.stringify({ type: 'error', error: err.message })
-      reply.raw.write(`data: ${errorEvent}\n\n`)
+    // Tell the client the run id first so it can reconnect via
+    // GET /api/chat/stream after a drop without losing the in-flight run.
+    res.write(`data: ${JSON.stringify({ type: 'run', run_id: runId, session_id: currentSessionId })}\n\n`)
+
+    await tailRunToResponse(res, runId, 0)
+    res.end()
+  })
+
+  // GET /api/chat/stream - Reconnect to an in-flight (or recently finished) run
+  // and resume tailing from `cursor`. This is what makes detached execution
+  // observable: a refreshed tab / dropped network reattaches here instead of
+  // starting a new run. Either run_id or workspace_id (to auto-find the active
+  // run) must be provided.
+  fastify.get('/api/chat/stream', async (request, reply) => {
+    if (!verifyToken(request)) {
+      reply.code(401)
+      return { success: false, error: 'Unauthorized' }
+    }
+
+    const workspaceId = request.query?.workspace_id || null
+    const runId = request.query?.run_id || chatRunManager.getActiveRunId(workspaceId)
+    const cursor = parseInt(request.query?.cursor, 10) || 0
+
+    if (!runId) {
+      reply.code(404)
+      return { success: false, error: 'No active run' }
     }
 
-    reply.raw.end()
+    reply.hijack()
+    const res = reply.raw
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    })
+    res.flushHeaders()
+    res.write(`data: ${JSON.stringify({ type: 'run', run_id: runId })}\n\n`)
+
+    await tailRunToResponse(res, runId, cursor)
+    res.end()
   })
 
   // GET /api/chat/session - Get active chat session for a workspace
@@ -101,8 +142,14 @@ async function chatRoutes(fastify) {
 
     const workspaceId = request.query?.workspace_id || null
     const session = chatStore.load(workspaceId)
+
+    // Surface any in-flight detached run so the client can attach to its live
+    // stream (GET /api/chat/stream) instead of rendering static history.
+    const activeRunId = chatRunManager.getActiveRunId(workspaceId)
+    const activeRun = activeRunId ? chatRunManager.getRunInfo(activeRunId) : null
+
     if (!session) {
-      return { success: true, session: null }
+      return { success: true, session: null, active_run: activeRun }
     }
 
     return {
@@ -115,6 +162,7 @@ async function chatRoutes(fastify) {
         created_at: session.created_at,
         updated_at: session.updated_at,
       },
+      active_run: activeRun,
     }
   })
 
@@ -159,31 +207,26 @@ async function chatRoutes(fastify) {
     return { success: true }
   })
 
-  // POST /api/chat/abort - Kill the active Claude CLI process
+  // POST /api/chat/abort - Explicitly kill the active run for a workspace.
+  // This is now the ONLY path that terminates the LLM. A dropped connection no
+  // longer does. Optionally accepts an explicit run_id.
   fastify.post('/api/chat/abort', async (request, reply) => {
     if (!verifyToken(request)) {
       reply.code(401)
       return { success: false, error: 'Unauthorized' }
     }
 
-    if (!activeChatChild) {
+    const workspaceId = request.body?.workspace_id || null
+    const runId = request.body?.run_id || chatRunManager.getActiveRunId(workspaceId)
+    if (!runId) {
       return { success: false, error: 'No active chat process' }
     }
 
-    console.log(`[Chat] Aborting active chat process PID: ${activeChatChild.pid}`)
-    activeChatChild.kill('SIGTERM')
-
-    // Give it 2s to terminate gracefully, then force kill
-    const pid = activeChatChild.pid
-    setTimeout(() => {
-      try {
-        if (activeChatChild && activeChatChild.pid === pid) {
-          activeChatChild.kill('SIGKILL')
-        }
-      } catch { /* already dead */ }
-    }, 2000)
-
-    return { success: true }
+    const aborted = chatRunManager.abort(runId)
+    if (!aborted) {
+      return { success: false, error: 'No active chat process' }
+    }
+    return { success: true, run_id: runId }
   })
 
   // POST /api/chat/reset - Carry over relevant messages and start fresh session
@@ -409,9 +452,11 @@ async function buildContextPrefix(message, context, sessionId, workspaceId, refe
       'このAPIは内部で Playwright + Readability を回し、抽出済みJSONだけを返すため、',
       'DOM全体がチャットに流れ込んでトークン肥大化することを防げる。',
       '初回アクセスで学習したセレクタはSQLiteにキャッシュされ、2回目以降はLLM呼び出しなしで抽出される。',
+      'SPA(クライアント描画)も内部でDOM静止を待ってから抽出するためそのまま利用可。',
+      '無限スクロールで件数を増やしたい場合は `"scroll": {"strategy":"count","targetItems":50}` を付ける(どれだけ集めるかは呼び出し側が指定)。',
       '',
-      'Playwright MCP (`mcp__playwright__*`) は **ログイン・フォーム入力・複数画面の対話操作**が必要な場合のみ使用する。',
-      '単純な閲覧・要約・一覧取得用途ではMCPを使わない。',
+      'Playwright MCP (`mcp__playwright__*`) は **ログイン・フォーム入力・複数画面の対話操作・「もっと見る」ボタン**が必要な場合のみ使用する。',
+      '単純な閲覧・要約・一覧取得用途(SPA・無限スクロール含む)ではMCPを使わない。',
       '',
       'HQ (`*.minion-agent.com`) のページURLは **Playwrightで開かずAPIで取得する**。ノートは `GET $HQ_URL/api/minion/workspaces/:wsId/notes/:id`、タスクは `GET $HQ_URL/api/minion/projects/:pid/tasks/:id`。チャットで参照されたノート/タスクの本文は上記「参照ノート」「参照チケット」ブロックに既に注入済み。',
       ''
@@ -425,6 +470,7 @@ async function buildContextPrefix(message, context, sessionId, workspaceId, refe
       '成果物の保存先は以下のルールに従うこと。`/home/minion/` 直下にファイルを保存しないこと。',
       '',
       '- **テキスト成果物**（レポート、調査結果、要約等）→ ノートに保存: `hq note create <project_id> --title "タイトル" --content "本文"` (プロジェクト紐づけなしは `hq note create --workspace <ws_id> ...`)',
+      '  - ロックされたノートの更新は `HTTP 423`（`note_locked`）で拒否される。解除は人間のみ可能なので、上書きを繰り返さずユーザーに依頼すること。',
       '- **バイナリファイル**（PDF、画像、ZIP等）→ `~/files/` に配置（ユーザーがHQからダウンロード可能）',
       '- **一時ファイル** → `/tmp/` に配置（作業後に削除）',
       '',
@@ -569,99 +615,109 @@ function getLlmBinary() {
 }
 
 /**
- * Stream LLM CLI output as SSE events.
- * Uses --resume to continue existing sessions.
- * Tracks block types to correctly forward tool_use vs text events
- * and counts turns for session management.
+ * Tail a detached run into an SSE response. Subscribes from `cursor`, forwards
+ * each event (seq-stamped, so the client can resume), and resolves on the
+ * terminal `done` event OR when the client disconnects. Disconnecting only
+ * stops the tail — it never touches the underlying LLM process.
+ *
+ * @param {import('http').ServerResponse} res
+ * @param {string} runId
+ * @param {number} cursor   last sequence the client already has
+ */
+function tailRunToResponse(res, runId, cursor) {
+  return new Promise(resolve => {
+    let settled = false
+    let unsubscribe = () => {}
+    const finish = () => {
+      if (settled) return
+      settled = true
+      try { unsubscribe() } catch { /* ignore */ }
+      resolve()
+    }
+
+    unsubscribe = chatRunManager.subscribe(runId, cursor, event => {
+      try { res.write(`data: ${JSON.stringify(event)}\n\n`) } catch { /* socket gone */ }
+      // The manager always closes a run with a terminal `done` (an `error`
+      // precedes it when the run failed), so `done` is our single stop signal.
+      if (event.type === 'done') finish()
+    })
+
+    // Client went away (tab close, navigation, proxy timeout, network blip):
+    // stop forwarding, but leave the run running so a reconnect can resume it.
+    res.on('close', finish)
+  })
+}
+
+/**
+ * Build the LLM executor for a run. The executor is LLM-specific (plugin vs
+ * legacy CLI) but knows nothing about HTTP — it emits normalized wire events
+ * and returns the collected result. The run manager owns persistence, the
+ * terminal `done` event, and abort.
+ *
+ * @param {string} prompt
+ * @param {string|null} sessionId
+ * @returns {(emit: (e: object) => void, activeRef: { current: any }) => Promise<{ fullResponse: string, resolvedSessionId: string|null, turnCount: number }>}
  */
-async function streamLlmResponse(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
-  // Plugin system path: Primary is set → delegate to plugin
+function buildInvoke(prompt, sessionId) {
   const primary = getActivePrimary()
   if (primary) {
-    return streamViaPlugin(primary, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
+    return (emit, activeRef) => invokeViaPlugin(primary, prompt, sessionId, emit, activeRef)
   }
-  return streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId)
+  return (emit, activeRef) => invokeViaLegacy(prompt, sessionId, emit, activeRef)
 }
 
-async function streamViaPlugin(plugin, res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
+async function invokeViaPlugin(plugin, prompt, sessionId, emit, activeRef) {
   const input = { prompt }
-  const activeRef = { current: null }
-  activeChatChild = { kill: () => activeRef.current?.kill?.('SIGTERM') }
-
   let fullResponse = ''
   let resolvedSessionId = sessionId || null
   let turnCount = 0
 
-  const emit = event => {
+  // Translate plugin events into wire events. `session` is captured (not
+  // forwarded); delta/text are accumulated; everything else is forwarded as-is.
+  const onEvent = event => {
     if (event.type === 'session') {
       resolvedSessionId = event.sessionId
     } else if (event.type === 'delta') {
       fullResponse += event.content
-      res.write(`data: ${JSON.stringify({ type: 'delta', content: event.content })}\n\n`)
+      emit({ type: 'delta', content: event.content })
     } else if (event.type === 'text') {
       fullResponse += event.content
-      res.write(`data: ${JSON.stringify({ type: 'text', content: event.content })}\n\n`)
+      emit({ type: 'text', content: event.content })
       turnCount++
     } else {
-      res.write(`data: ${JSON.stringify(event)}\n\n`)
+      emit(event)
     }
   }
 
-  res.on('close', () => { activeRef.current?.kill?.('SIGTERM') })
-
-  let pluginError = null
   try {
     let output
     if (plugin.capabilities.streaming && typeof plugin.stream === 'function') {
-      output = await plugin.stream(input, emit, { resumeSessionId: sessionId, activeChildRef: activeRef })
+      output = await plugin.stream(input, onEvent, { resumeSessionId: sessionId, activeChildRef: activeRef })
     } else {
       output = await plugin.invoke(input)
       if (output.text) {
         fullResponse = output.text
-        res.write(`data: ${JSON.stringify({ type: 'text', content: output.text })}\n\n`)
+        emit({ type: 'text', content: output.text })
         turnCount = 1
       }
       if (output.error) {
-        res.write(`data: ${JSON.stringify({ type: 'error', error: output.error.message })}\n\n`)
+        emit({ type: 'error', error: output.error.message })
       }
     }
     resolvedSessionId = output?.metadata?.sessionId || resolvedSessionId
-  } catch (err) {
-    // Swallow here so we can persist any partial response first; rethrow below.
-    pluginError = err
-  } finally {
-    activeChatChild = null
-  }
-
-  // For new sessions, the user message was persisted under pendingSessionId
-  // before the plugin call. Rekey it to the real session ID now that we
-  // know it. If the plugin never reported a session ID, leave the message
-  // under the pending key so the history isn't lost.
-  const persistSessionId = resolvedSessionId || pendingSessionId
-  try {
-    if (!sessionId && resolvedSessionId && pendingSessionId && pendingSessionId !== resolvedSessionId) {
-      chatStore.rekeySession(pendingSessionId, resolvedSessionId)
-    }
-    if (fullResponse && persistSessionId) {
-      await chatStore.addMessage(persistSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
+    if (output?.error) {
+      emit({ type: 'error', error: output.error.message, partial: !!fullResponse })
     }
   } catch (err) {
-    console.error('[Chat] failed to persist assistant message:', err.message)
+    // Surface the error inline but still return the partial so the manager can
+    // persist it. (A spawn failure typically yields no partial.)
+    emit({ type: 'error', error: err.message, partial: !!fullResponse })
   }
 
-  if (pluginError) throw pluginError
-
-  let totalTurnCount = turnCount
-  try {
-    const session = await chatStore.load(workspaceId)
-    totalTurnCount = session?.turn_count || turnCount
-  } catch (err) {
-    console.error('[Chat] failed to load session for done event:', err.message)
-  }
-  res.write(`data: ${JSON.stringify({ type: 'done', session_id: resolvedSessionId, turn_count: totalTurnCount })}\n\n`)
+  return { fullResponse, resolvedSessionId, turnCount }
 }
 
-function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, originalMessage, pendingSessionId) {
+function invokeViaLegacy(prompt, sessionId, emit, activeRef) {
   return new Promise((resolve, reject) => {
     const binaryName = getLlmBinary()
     if (!binaryName) {
@@ -672,20 +728,8 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
     const binary = fs.existsSync(binaryPath) ? binaryPath : binaryName
 
     // Build CLI args (no --max-turns: allow unlimited turns for task completion)
-    const args = [
-      '-p',
-      '--verbose',
-      '--model', 'sonnet',
-      '--output-format', 'stream-json',
-    ]
-
-    // Resume existing session
-    if (sessionId) {
-      args.push('--resume', sessionId)
-    }
-
-    // Prompt is passed via stdin (not as CLI argument) to avoid
-    // shell argument parsing issues with spaces/special characters.
+    const args = ['-p', '--verbose', '--model', 'sonnet', '--output-format', 'stream-json']
+    if (sessionId) args.push('--resume', sessionId)
 
     console.log(`[Chat] spawning: ${binary} ${sessionId ? `--resume ${sessionId}` : '(new session)'} (cwd: ${config.HOME_DIR})`)
 
@@ -697,21 +741,17 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
       timeout: 3600000, // 60 min — allow long-running tasks to complete
     })
 
-    // Track active child process for abort
-    activeChatChild = child
+    // Expose the child to the run manager for abort. NOT tied to any HTTP request.
+    activeRef.current = 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}`)
 
     let fullResponse = ''
     let stderrBuffer = ''
     let lineBuffer = ''
     let resolvedSessionId = sessionId || null
-
-    // Block-type state tracking for correct event forwarding
     let currentBlockType = null  // 'text' | 'tool_use' | null
     let currentToolName = null
     let toolInputBuffer = ''
@@ -720,7 +760,6 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
     child.stdout.on('data', (data) => {
       lineBuffer += data.toString()
       const parts = lineBuffer.split('\n')
-      // Keep the last (potentially incomplete) line in the buffer
       lineBuffer = parts.pop() || ''
 
       for (const line of parts) {
@@ -728,96 +767,69 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
         try {
           const parsed = JSON.parse(line)
 
-          // system init event — capture session_id
           if (parsed.type === 'system' && parsed.session_id) {
             resolvedSessionId = parsed.session_id
             console.log(`[Chat] session_id: ${resolvedSessionId}`)
           }
 
-          // content_block_start — track block type
           if (parsed.type === 'content_block_start') {
             const blockType = parsed.content_block?.type
             if (blockType === 'tool_use') {
               currentBlockType = 'tool_use'
               currentToolName = parsed.content_block.name || 'unknown'
               toolInputBuffer = ''
-              const event = JSON.stringify({
-                type: 'tool_start',
-                tool: currentToolName,
-              })
-              res.write(`data: ${event}\n\n`)
+              emit({ type: 'tool_start', tool: currentToolName })
             } else if (blockType === 'text') {
               currentBlockType = 'text'
             }
           }
 
-          // content_block_delta — handle both text and tool input
           if (parsed.type === 'content_block_delta') {
             const deltaType = parsed.delta?.type
             if (deltaType === 'input_json_delta' && currentBlockType === 'tool_use') {
-              // Accumulate tool input JSON
               const partial = parsed.delta.partial_json || ''
               if (partial) {
                 toolInputBuffer += partial
-                const event = JSON.stringify({ type: 'tool_input_delta', partial_json: partial })
-                res.write(`data: ${event}\n\n`)
+                emit({ type: 'tool_input_delta', partial_json: partial })
               }
             } else {
-              // Text delta
               const delta = parsed.delta?.text || ''
               if (delta) {
                 fullResponse += delta
-                const event = JSON.stringify({ type: 'delta', content: delta })
-                res.write(`data: ${event}\n\n`)
+                emit({ type: 'delta', content: delta })
               }
             }
           }
 
-          // content_block_stop — only emit tool_end for tool_use blocks (bug fix)
           if (parsed.type === 'content_block_stop') {
             if (currentBlockType === 'tool_use') {
-              // Try to parse the accumulated tool input
               let parsedInput = null
               try {
                 if (toolInputBuffer) parsedInput = JSON.parse(toolInputBuffer)
               } catch { /* partial or invalid JSON */ }
-              const event = JSON.stringify({
-                type: 'tool_end',
-                tool: currentToolName,
-                input: parsedInput,
-              })
-              res.write(`data: ${event}\n\n`)
+              emit({ type: 'tool_end', tool: currentToolName, input: parsedInput })
             }
             currentBlockType = null
             currentToolName = null
             toolInputBuffer = ''
           }
 
-          // assistant message — count turns and forward text blocks
           if (parsed.type === 'assistant' && parsed.message) {
             turnCount++
             for (const block of (parsed.message.content || [])) {
               if (block.type === 'text') {
                 fullResponse += block.text
-                const event = JSON.stringify({ type: 'text', content: block.text })
-                res.write(`data: ${event}\n\n`)
+                emit({ type: 'text', content: block.text })
               }
             }
           } else if (parsed.type === 'result') {
-            // result event — forward but do NOT overwrite accumulated fullResponse
             const resultText = parsed.result || ''
             if (resultText) {
-              const event = JSON.stringify({ type: 'result', content: resultText })
-              res.write(`data: ${event}\n\n`)
-              // Use result as fullResponse only if nothing was accumulated
-              // (single-turn responses without deltas)
-              if (!fullResponse) {
-                fullResponse = resultText
-              }
+              emit({ type: 'result', content: resultText })
+              if (!fullResponse) fullResponse = resultText
             }
           }
         } catch {
-          // Non-JSON line — ignore
           console.warn(`[Chat] ignoring non-JSON line: ${line.substring(0, 80)}`)
         }
       }
@@ -829,72 +841,26 @@ function streamViaLegacyLlmCommand(res, prompt, sessionId, workspaceId, original
       console.error(`[Chat] stderr: ${text}`)
     })
 
-    child.on('close', async (code) => {
-      activeChatChild = null
-
+    child.on('close', (code) => {
+      activeRef.current = null
       console.log(`[Chat] child closed: code=${code}, response=${fullResponse.length}chars, turns=${turnCount}, stderr=${stderrBuffer.length}bytes, session=${resolvedSessionId}`)
       if (stderrBuffer.trim()) {
         console.log(`[Chat] final stderr (tail 500): ${stderrBuffer.slice(-500)}`)
       }
-
-      // For new sessions, the user message was already persisted under
-      // pendingSessionId before spawn. Rekey it to the real session ID when
-      // Claude CLI reported one; otherwise leave the message under the
-      // pending key so the history is never lost on crash.
-      const persistSessionId = resolvedSessionId || pendingSessionId
-      try {
-        if (!sessionId && resolvedSessionId && pendingSessionId && pendingSessionId !== resolvedSessionId) {
-          chatStore.rekeySession(pendingSessionId, resolvedSessionId)
-        }
-        // Persist any partial response we managed to collect, even on error
-        if (fullResponse && persistSessionId) {
-          await chatStore.addMessage(persistSessionId, { role: 'assistant', content: fullResponse }, turnCount, workspaceId)
-        }
-      } catch (err) {
-        console.error('[Chat] failed to persist assistant message:', err.message)
-      }
-
       if (code !== 0) {
         const errorMsg = stderrBuffer.trim() || `Claude CLI exited with code ${code}`
         console.error(`[Chat] CLI failed (exit ${code}, partial=${!!fullResponse}): ${errorMsg}`)
-        const errorEvent = JSON.stringify({
-          type: 'error',
-          error: errorMsg,
-          partial: !!fullResponse,
-          exit_code: code,
-        })
-        res.write(`data: ${errorEvent}\n\n`)
-      }
-
-      // Load current turn count from session for the done event
-      let totalTurnCount = turnCount
-      try {
-        const session = await chatStore.load(workspaceId)
-        totalTurnCount = session?.turn_count || turnCount
-      } catch (err) {
-        console.error('[Chat] failed to load session for done event:', err.message)
+        emit({ type: 'error', error: errorMsg, partial: !!fullResponse, exit_code: code })
       }
-
-      const doneEvent = JSON.stringify({
-        type: 'done',
-        session_id: resolvedSessionId,
-        turn_count: totalTurnCount,
-      })
-      res.write(`data: ${doneEvent}\n\n`)
-      resolve()
+      // Resolve (don't reject) on non-zero exit so the manager persists the
+      // partial response and emits a clean terminal `done`.
+      resolve({ fullResponse, resolvedSessionId, turnCount })
     })
 
     child.on('error', (err) => {
-      activeChatChild = null
+      activeRef.current = null
       console.error(`[Chat] spawn error: ${err.message}`)
-      const errorEvent = JSON.stringify({ type: 'error', error: `Failed to start Claude CLI: ${err.message}` })
-      res.write(`data: ${errorEvent}\n\n`)
-      reject(err)
-    })
-
-    // Handle client disconnect
-    res.on('close', () => {
-      child.kill('SIGTERM')
+      reject(new Error(`Failed to start Claude CLI: ${err.message}`))
     })
   })
 }

package/package.json

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

package/rules/core.md

@@ -132,7 +132,15 @@ curl -X POST http://localhost:8080/api/web/extract \
 
 レシピは初回アクセス時に LLM (Haiku) で生成・SQLite (`page_recipes` テーブル) に保存され、2回目以降の構造的に同じページでは LLM 呼び出しなしで抽出される。
 
-Playwright MCP (`mcp__playwright__*`) は **フォーム入力・クリック・複数画面遷移など対話的な操作**が必要な場合のみ使用すること。単に「ページを読む」目的では MCP を使わない。
+**SPA / 無限スクロール (v4.7.0〜):** SPA (クライアント描画) は内部で DOM が静止するまで待ってから抽出するためそのまま利用できる。無限スクロールで件数を確保したい場合は `scroll` オプションを付ける（どれだけ集めるかは呼び出し側が指定。`scrollInfo.reachedTarget=false` なら上限打ち切りなので `maxScrolls`/`maxMs` を上げて再試行）:
+
+```bash
+curl -X POST http://localhost:8080/api/web/extract \
+  -H "Authorization: Bearer $API_TOKEN" -H "Content-Type: application/json" \
+  -d '{"url": "対象URL", "scroll": {"strategy": "count", "targetItems": 50, "maxScrolls": 20}}'
+```
+
+Playwright MCP (`mcp__playwright__*`) は **フォーム入力・クリック・複数画面遷移・「もっと見る」ボタンなど対話的な操作**が必要な場合のみ使用すること。単に「ページを読む」目的 (SPA・無限スクロール含む) では MCP を使わない。
 
 **実験的機能**: レスポンス形状は予告なく変わる可能性がある。要件: (1) primary LLM 設定済み (`PUT /api/llm/config` で `claude` 等を選択、`hq llm primary <name>` でも可) または `ANTHROPIC_API_KEY` シークレット設定済み、(2) ホスト上で `npx playwright install chromium` 実行済み。primary LLM が設定されていれば API キー不要 (Claude Code CLI の認証情報を再利用)。
 
@@ -238,7 +246,7 @@ Routine 実行中は以下もtmuxセッション環境で利用可能:
 - `MINION_ROUTINE_NAME` — ルーティン名
 - `MINION_ROUTINE_WORKSPACE_ID` — ルーティンが特定ワークスペースにバインドされている場合のワークスペースUUID（未バインドなら空文字）
 
-**変数**（ワークスペース変数・プロジェクト変数・ワークフロー変数・ミニオン変数）はスキル本文の `{{VAR_NAME}}` テンプレートとして実行時に展開される。スキル作成時にパラメータ化したい値は `{{変数名}}` で記述すること。展開優先順位: ワークスペース < プロジェクト < ワークフロー < ミニオン（後者が優先）。ミニオンが最終オーバーライドとなる設計で、ミニオン運用者がHQ側のデフォルトを差し替えられる経路を保証する。ミニオン変数はさらにミニオン全体スコープとワークスペース別スコープに分かれ、当該ワークスペースのコンテキストで動く実行時はWS別がミニオン全体を上書きする。`/api/variables/*` は `?workspace_id=<uuid>` でスコープ指定（省略時はミニオン全体）。
+**変数**（ワークスペース変数・プロジェクト変数・ワークフロー変数・ミニオン変数）はスキル本文の `{{VAR_NAME}}` テンプレートとして実行時に展開される。スキル作成時にパラメータ化したい値は `{{変数名}}` で記述すること。展開優先順位: ワークスペース < プロジェクト < ワークフロー < ミニオン（後者が優先）。ミニオンが最終オーバーライドとなる設計で、ミニオン運用者がHQ側のデフォルトを差し替えられる経路を保証する。ミニオン変数はさらにミニオン全体スコープとワークスペース別スコープに分かれ、当該ワークスペースのコンテキストで動く実行時はWS別がミニオン全体を上書きする。`/api/variables/*` は `?workspace_id=<uuid>` でスコープ指定（省略時はミニオン全体）。誤ったスコープに登録してしまった変数・シークレットは `POST /api/variables/:key/move`・`POST /api/secrets/:key/move`（body: `{from_workspace_id, to_workspace_id}`）で削除・再登録せずに別スコープへ移動できる。移動先に同名キーがある場合は上書きせず `409` を返す。
 
 DAGワークフローでは、HQ側スコープ（workspace/project/dag_workflow）の変数は **`POST /api/dag/minion/claim-node` のレスポンス `template_vars`** に乗って降ってきて、ミニオン側で minion-local 変数とマージしたうえで `POST /api/skills/fetch/:name?vars=...` の base64 JSON に詰めて HQ に渡し、HQ 側で SKILL.md の `{{VAR}}` を置換して返す。つまり HQ-scope 変数の更新は **次のノード claim から反映される**（既存のミニオン上 SKILL.md は次回 fetch で上書きされる）。DAGワークフロー単位の変数は `dag_workflow_variables` テーブルに格納され、DAGエディタの "Variables" ボタンから編集可能。
 
@@ -485,6 +493,8 @@ hq note search --workspace <workspace_id> "キーワード"
 
 **削除はミニオンから実行できない**(事故防止のため人間操作限定)。不要なノートは `hq note update ... --status archived` (または PATCH の `status: "archived"`) でアーカイブすること。
 
+**ロックされたノートは更新できない。** ユーザーがパスワード等を保護するために「ロック」したノートは、`hq note update` / PATCH が `HTTP 423`(`{"code":"note_locked"}`)で拒否される。**ロック解除は人間のみ**が HQ ダッシュボードで行えるため、ミニオンは解除できない。423 を受けたら上書きを繰り返さず、更新が必要な場合は threads でユーザーにロック解除を依頼すること。
+
 ### ノート内のユーザーメンション
 
 人間ユーザーがノート編集UIで `Ctrl+I` を押すと、自分の発言を示すアバター付きチップが行頭に挿入される。マークダウン上は次の形式で永続化される: