Hive-mind worker tracking is non-functional: task lifecycle never syncs agent state

[clement-livdeo]

Related

Follow-up to #1391 (wrong MCP tool prefix in hive-mind prompt). This issue covers the underlying tracking pipeline that makes workers permanently show idle with 0 completed tasks.

Summary

When using hive-mind spawn --claude, the spawned queen is instructed to coordinate virtual workers via task tools. However, nothing connects the task system to the agent system:

1. task_assign writes agent IDs to tasks/store.json but never updates agents.json → workers stay idle forever, currentTask stays null
2. task_complete marks the task done but never increments the worker's taskCount → Completed column in rf-status stays at 0
3. hive-mind_status reports queen.load as 0.3 + Math.random() * 0.4 (line 266 of hive-mind-tools.js) — a random number, not derived from actual task state
4. queen.tasksQueued reads from consensus.pending.length instead of pending tasks

The result: hive-mind status always shows all workers as idle / 0 completed regardless of actual work done, and queen load is random noise.

Version

ruflo v3.5.41

Steps to Reproduce

ruflo hive-mind init -t hierarchical-mesh
ruflo hive-mind spawn -n 3
# Use MCP tools:
# 1. task_create → get taskId
# 2. task_assign(taskId, [workerId])
# 3. task_complete(taskId)
# 4. Check: ruflo hive-mind status

Expected Behavior

After task_assign, the assigned worker should show status: active and currentTask: <taskId>. After task_complete, the worker should return to idle with taskCount incremented. Queen load should reflect active tasks / worker count.

Actual Behavior

Workers permanently show idle, Completed: 0, Current Task: -. Queen load is Math.random().

Root Cause

task-tools.ts and hive-mind-tools.ts operate on separate JSON files (tasks/store.json vs agents.json) with zero cross-references:

• task_assign handler (task-tools.ts ~L279-300): writes task.assignedTo = agentIds, saves task store. Does NOT touch agent store.
• task_complete handler (task-tools.ts ~L194-216): sets task.status = 'completed', saves task store. Does NOT update agent taskCount or status.
• hive-mind_status handler (hive-mind-tools.ts ~L266): load: 0.3 + Math.random() * 0.4

The v2 codebase (v2/src/hive-mind/core/HiveMind.ts) had EventEmitter-based lifecycle events, a SwarmOrchestrator, and auto-assignment. The v3 rewrite replaced this with flat JSON CRUD that lost the cross-system linkage.

Suggested Fix

task_assign handler — sync agent state on assignment

When a task is assigned to workers:

• Set agent.status = 'active' and agent.currentTask = taskId in agents.json
• Auto-transition task to in_progress if it was pending
• On unassign: revert worker to idle

task_complete handler — sync agent state on completion

When a task completes:

• Set assigned agents back to status: 'idle', currentTask: null
• Increment agent.taskCount

hive-mind_status handler — real metrics

Replace:

load: 0.3 + Math.random() * 0.4
tasksQueued: state.consensus.pending.length

With:

load: activeTaskCount / Math.max(1, workerCount)
tasksQueued: pendingTaskCount  // from tasks/store.json

Prompt — explicit lifecycle instructions

The queen prompt (generateHiveMindPrompt()) should explicitly instruct: task_create → task_assign(workerId) → [do work] → task_complete for every subtask, with round-robin worker selection.

Files to Fix

• v3/@claude-flow/cli/src/mcp-tools/task-tools.ts — task_assign and task_complete handlers
• v3/@claude-flow/cli/src/mcp-tools/hive-mind-tools.ts — hive-mind_status handler (line ~266)
• v3/@claude-flow/cli/src/commands/hive-mind.ts — generateHiveMindPrompt() execution protocol

Local Patch Verified

I've patched all three files locally on v3.5.41 and verified the full cycle works:

• task_assign → worker goes active, shows currentTask
• task_complete → worker returns idle, Completed increments
• Queen load shows real ratio (e.g., 33.3% = 1 active task / 3 workers)

Happy to submit a PR if the approach is acceptable.

[ruvnet]

Fixed in v3.5.42 — published to npm.

All three suggested fixes from the issue have been implemented:

1. task_assign handler — syncs agent state on assignment

• Sets agent.status = 'active' and agent.currentTask = taskId in agents.json
• Auto-transitions task to in_progress if it was pending
• On unassign or reassign: reverts previous agents to idle

2. task_complete handler — syncs agent state on completion

• Sets assigned agents back to status: 'idle', currentTask: null
• Increments agent.taskCount

3. hive-mind_status handler — real metrics

• Replaced load: 0.3 + Math.random() * 0.4 with load: activeTaskCount / workerCount
• Replaced tasksQueued: state.consensus.pending.length with actual pending task count from tasks/store.json
• Added activeTasks and pendingTasks to metrics
• Loads agent store once instead of per-worker (performance fix)

Commit: 263a68f

[nriccar]

Swarm agents still do not execute work — v3.5.42 (@claude-flow/cli@latest)

  The state-tracking fix from this issue was correctly applied — task_assign now transitions
  tasks to in_progress. However, agents never execute the assigned work. The fundamental issue
  is that no execution engine exists: MCP tools perform JSON CRUD on registry files, but
  nothing spawns a Claude subprocess to read the task description and act on it.

  Environment

  - Package: @claude-flow/cli@latest (npm version 3.5.42, internal version string 10.8.2)
  - Platform: macOS Darwin 24.6.0
  - Client: Claude Code (Opus 4.6)
  - MCP config: autoStart: false in .mcp.json

  Test 1 — Full swarm via MCP tools (first session)

  swarm_init → topology: hierarchical, strategy: specialized, maxAgents: 8
    ✅ Success: swarm-1774027567036-4ozd3b

  agent_spawn × 7 (architect, backend, frontend, manual-qa, tester, reviewer, qa)
    ✅ All spawned, status: "idle", health: 1

  swarm_health:
    ✅ status: "healthy"
    ❌ agentCount: 0  ← agents not registered in swarm scope despite 7 spawned

  task_create (type: feature, priority: critical, assignTo: ["dashboard-map-architect"])
    ✅ taskId: task-1774027636063-dkvwp5, status: "pending"

  Poll results (every 15s for 60s):

  Poll 1 (0s):   task=pending  agent=idle  taskCount=0  currentTask=null
  Poll 2 (15s):  task=pending  agent=idle  taskCount=0  currentTask=null
  Poll 3 (30s):  task=pending  agent=idle  taskCount=0  currentTask=null
  Poll 4 (45s):  task=pending  agent=idle  taskCount=0  currentTask=null

  Stuck detected at 60s. Attempted recovery:

  task_assign(taskId, ["dashboard-map-architect"])
    ✅ Task status changed: pending → in_progress (the #1392 fix works for tracking)
    ✅ startedAt populated: 2026-03-20T17:29:12.065Z
    ❌ Agent still idle, taskCount still 0

  30s after re-assign:

  task=in_progress  progress=0  agent=idle  taskCount=0

  No files created. No reasoning happened. Aborted.

  Test 2 — CLI swarm start (same session)

  Tested the v2-documented CLI approach:

  $ claude-flow swarm start -o "write hello.txt" -s development

  [INFO] Starting swarm with objective: write hello.txt

  Agent Deployment Plan
  +-------------+-------------+-------+----------------------+
  | Role        | Type        | Count | Purpose              |
  +-------------+-------------+-------+----------------------+
  | Coordinator | coordinator |     1 | Orchestrate workflow |
  | Architect   | architect   |     1 | System design        |
  | Coder       | coder       |     3 | Implementation       |
  | Tester      | tester      |     2 | Quality assurance    |
  | Reviewer    | reviewer    |     1 | Code review          |
  +-------------+-------------+-------+----------------------+

  [OK] Swarm execution started
    Monitor: claude-flow swarm status swarm-mmz6o5ij

  $ claude-flow swarm status swarm-mmz6o5ij

  Swarm Status: swarm-mmz6o5ij
  Overall Progress: [##--------------------------------------] 5.0%

  Agents:    Active: 0  Idle: 0  Completed: 0  Total: 0
  Tasks:     Completed: 0  In Progress: 0  Pending: 0  Total: 0
  Tokens Used: 0

  Same result — agents "deployed" but 0 active, 0 tasks, 0 tokens. hello.txt never created.

  Test 3 — Fresh session POC (new Claude session, clean MCP server)

  Exited Claude entirely, started a new session to rule out stale MCP state:

  swarm_init → topology: mesh, strategy: balanced, maxAgents: 2
    ✅ swarm-1774028539625-xa6vy4

  agent_spawn (agentId: "poc-worker", type: coder, model: haiku)
    ✅ status: "spawned"

  task_create (description: "Create poc-test.txt containing 'swarm test passed'", assignTo:
  ["poc-worker"])
    ✅ taskId: task-1774028552187-3dlgkj, status: "pending"

  Immediate poll:

  task:  status=pending  progress=0  startedAt=null
  agent: status=idle  taskCount=0
  swarm: agentCount=0  ← still 0 despite agent spawned

  After 15s:

  task:  status=pending  progress=0  startedAt=null  (no change)
  agent: status=idle  taskCount=0  (no change)

  $ ls poc-test.txt
  ls: poc-test.txt: No such file or directory

  Identical behavior across fresh session. Not a caching/session issue.

  Diagnosis

  ┌───────────────────────────┬───────────┬────────────────────────────────────────────────┐
  │           What            │  Status   │                     Detail                     │
  ├───────────────────────────┼───────────┼────────────────────────────────────────────────┤
  │ agent_spawn creates agent │ ✅ Works  │ Writes to agents.json                          │
  │  record                   │           │                                                │
  ├───────────────────────────┼───────────┼────────────────────────────────────────────────┤
  │ task_create creates task  │ ✅ Works  │ Writes to tasks/store.json                     │
  │ record                    │           │                                                │
  ├───────────────────────────┼───────────┼────────────────────────────────────────────────┤
  │ task_assign links task →  │ ✅ Works  │ Sets task.assignedTo, transitions to           │
  │ agent                     │           │ in_progress (#1392 fix)                        │
  ├───────────────────────────┼───────────┼────────────────────────────────────────────────┤
  │ Agent transitions to      │ ❌ Broken │ Agent stays idle, taskCount: 0                 │
  │ active                    │           │                                                │
  ├───────────────────────────┼───────────┼────────────────────────────────────────────────┤
  │ Swarm sees spawned agents │ ❌ Broken │ swarm_health shows agentCount: 0               │
  ├───────────────────────────┼───────────┼────────────────────────────────────────────────┤
  │ Agent reads task and      │ ❌        │ No subprocess spawned, no file I/O, no         │
  │ executes                  │ Missing   │ reasoning                                      │
  ├───────────────────────────┼───────────┼────────────────────────────────────────────────┤
  │ CLI swarm start executes  │ ❌        │ Same metadata-only pattern                     │
  │ work                      │ Missing   │                                                │
  └───────────────────────────┴───────────┴────────────────────────────────────────────────┘

  Root cause

  The v3 rewrite replaced the v2 execution engine (SwarmOrchestrator + EventEmitter lifecycle +
   subprocess management) with flat JSON CRUD. The MCP tools manage coordination metadata but
  nothing consumes that metadata to dispatch work:

  1. agent_spawn → writes { agentId, status: "idle" } to agents.json
  2. task_create → writes { taskId, status: "pending", assignedTo } to tasks/store.json
  3. task_assign → updates both records (the #1392 fix)
  4. Missing step: nothing reads the task queue, matches assigned agents, and launches a Claude
   subprocess to execute the task description

  The v2 docs (v2/docs/reference/SWARM.md) describe claude-flow swarm execute "task" which
  presumably triggered the SwarmOrchestrator. The v3 CLI has swarm start but it only writes
  metadata — the orchestrator was not ported.

  What #1392 fixed vs what's still broken

  - Fixed: task_assign now correctly cross-references tasks/store.json ↔ agents.json (status
  transitions, startedAt population)
  - Still broken: No execution engine — agents are database rows, not running processes

  Suggestion

  The v3 MCP tools need a task consumer/dispatcher that:
  1. Watches the task store for pending/in_progress tasks with assigned agents
  2. Launches a real Claude subprocess (via claude CLI or API) with the task description as the
   prompt
  3. Updates agent status to active while the subprocess runs
  4. Captures output and marks task completed when the subprocess finishes

  Alternatively, document that the MCP tools are a coordination layer only and that execution
  must be handled externally (e.g., by Claude Code's Agent tool reading task descriptions from
  the store).

[nriccar]

@ruvnet