@hueyexe/opencode-ensemble 0.15.2 → 0.16.1

package/src/index.ts

@@ -16,6 +16,7 @@ import { log, initLog } from "./log"
 import { findTeamBySession } from "./types"
 import { loadConfig } from "./config"
 import { ProgressTracker } from "./progress"
+import { ActivityBuffer, recordFromV2Event, recordFromToolBefore, recordFromToolAfter } from "./activity"
 import { startDashboard } from "./dashboard"
 import { executeTeamCreate } from "./tools/team-create"
 import { executeTeamSpawn } from "./tools/team-spawn"
@@ -59,6 +60,7 @@ const plugin: Plugin = async (input) => {
   const purgeApprovals = new PendingPurgeApprovals()
   const nudgedMembers = new Set<string>()
   const progressTracker = new ProgressTracker()
+  const activityBuffer = new ActivityBuffer()
   const wakeLeadTimestamps = new Map<string, number>()
   const WAKE_LEAD_COOLDOWN_MS = 5000
 
@@ -104,7 +106,7 @@ const plugin: Plugin = async (input) => {
 
     // Start dashboard server (main instance only, not worktree instances)
     if (config.dashboardPort !== 0) {
-      startDashboard(db, config.dashboardPort).catch((err) => {
+      startDashboard(db, config.dashboardPort, { activityBuffer, client }).catch((err) => {
         log(`init:dashboard:failed err=${err instanceof Error ? err.message : String(err)}`)
       })
     }
@@ -304,6 +306,15 @@ const plugin: Plugin = async (input) => {
           }
         }
       }
+
+      // Capture activity for dashboard verbose view (best-effort, v2 event types)
+      // Only shell and step events are recorded here — tool calls/results are
+      // recorded via tool.execute.before/after to avoid duplicate entries.
+      recordFromV2Event(
+        event as unknown as { type: string; properties: { sessionID?: string; tool?: string; input?: string; content?: string; title?: string; error?: string; command?: string; exitCode?: number; cost?: number; tokens?: { input?: number; output?: number } } },
+        registry,
+        activityBuffer,
+      )
     },
 
     // Sub-agent isolation + rate limiting hook
@@ -315,12 +326,16 @@ const plugin: Plugin = async (input) => {
           await rateLimiter.waitForToken()
         }
       }
+      // Record tool call activity for team member sessions
+      recordFromToolBefore(input, registry, activityBuffer)
     },
 
     "tool.execute.after": async (input, output) => {
       if (input.tool === "question") {
         purgeApprovals.recordQuestionAnswer(input.sessionID, output.output, input.args)
       }
+      // Record tool result activity for team member sessions
+      recordFromToolAfter(input, output, registry, activityBuffer)
     },
 
     // System prompt injection — keeps lead aware of team state, reminds teammates of role
@@ -508,7 +523,10 @@ const plugin: Plugin = async (input) => {
           const result = await executeTeamShutdown(deps, args, ctx.sessionID)
           // Clean up progress tracking for the shut-down member
           const member = deps.db.query("SELECT session_id FROM team_member WHERE name = ? AND status IN ('shutdown', 'shutdown_requested')").get(args.member) as { session_id: string } | null
-          if (member) progressTracker.remove(member.session_id)
+          if (member) {
+            progressTracker.remove(member.session_id)
+            activityBuffer.remove(member.session_id)
+          }
           const hasWarning = result.includes("uncommitted")
           ctx.metadata({ title: hasWarning ? `${args.member} shut down — uncommitted changes` : `${args.member} shut down` })
           return result
@@ -542,7 +560,16 @@ const plugin: Plugin = async (input) => {
               })
             }
             : undefined
+          // Collect member session IDs before cleanup so we can clean up activity buffers after
+          const teamInfoForCleanup = findTeamBySession(db, registry, ctx.sessionID)
+          const memberSessions = teamInfoForCleanup
+            ? (db.query("SELECT session_id FROM team_member WHERE team_id = ?").all(teamInfoForCleanup.teamId) as Array<{ session_id: string }>).map(m => m.session_id)
+            : []
           const result = await executeTeamCleanup(deps, args, ctx.sessionID, undefined, undefined, undefined, config.mergeOnCleanup, undefined, approvePurge)
+          // Clean up activity buffers for team members after successful cleanup
+          if (!result.includes("uncommitted") && !args.purge) {
+            for (const sid of memberSessions) activityBuffer.remove(sid)
+          }
           const blocked = result.includes("uncommitted")
           const title = args.purge
             ? result.startsWith("No archived teams") ? "No archived teams to purge" : result.startsWith("Purge preview") ? "Purge confirmation required" : "Archived teams purged"

package/src/tools/team-claim.ts

@@ -1,6 +1,37 @@
+import type { Database } from "../db"
 import type { ToolDeps } from "../types"
 import { requireTeamMember } from "./shared"
 
+/**
+ * Atomically claim a pending task for an assignee. Sets status to
+ * 'in_progress' and records the assignee. Throws if the task is missing,
+ * blocked, already claimed, or no longer pending. Returns the task content
+ * on success.
+ *
+ * Shared by team_claim and team_spawn's claim_task auto-claim so both paths
+ * enforce the same atomic claim invariant.
+ */
+export function claimTask(db: Database, teamId: string, taskId: string, assignee: string): string {
+  const task = db.query("SELECT content, status, assignee FROM team_task WHERE id = ? AND team_id = ?")
+    .get(taskId, teamId) as { content: string; status: string; assignee: string | null } | null
+  if (!task) throw new Error(`Task "${taskId}" not found`)
+  if (task.status === "blocked") throw new Error(`Task "${taskId}" is blocked by unresolved dependencies`)
+  if (task.status !== "pending") throw new Error(`Task "${taskId}" is not pending (status: ${task.status})`)
+  if (task.assignee) throw new Error(`Task "${taskId}" is already claimed by ${task.assignee}`)
+
+  // Atomic claim: UPDATE only if still pending and unassigned
+  const result = db.run(
+    "UPDATE team_task SET status = 'in_progress', assignee = ?, time_updated = ? WHERE id = ? AND status = 'pending' AND assignee IS NULL",
+    [assignee, Date.now(), taskId]
+  )
+
+  if (result.changes === 0) {
+    throw new Error(`Task "${taskId}" is already claimed (race condition)`)
+  }
+
+  return task.content
+}
+
 /**
  * Execute the team_claim tool. Atomically claims a pending task.
  * Rejects if the task is already claimed, blocked, or not pending.
@@ -13,23 +44,7 @@ export async function executeTeamClaim(
   const teamInfo = requireTeamMember(deps, sessionId)
 
   const claimerName = teamInfo.role === "lead" ? "lead" : (teamInfo.memberName ?? "unknown")
+  const content = claimTask(deps.db, teamInfo.teamId, args.task_id, claimerName)
 
-  const task = deps.db.query("SELECT * FROM team_task WHERE id = ? AND team_id = ?")
-    .get(args.task_id, teamInfo.teamId) as Record<string, unknown> | null
-  if (!task) throw new Error(`Task "${args.task_id}" not found`)
-  if (task.status === "blocked") throw new Error(`Task "${args.task_id}" is blocked by unresolved dependencies`)
-  if (task.status !== "pending") throw new Error(`Task "${args.task_id}" is not pending (status: ${task.status})`)
-  if (task.assignee) throw new Error(`Task "${args.task_id}" is already claimed by ${task.assignee}`)
-
-  // Atomic claim: UPDATE only if still pending and unassigned
-  const result = deps.db.run(
-    "UPDATE team_task SET status = 'in_progress', assignee = ?, time_updated = ? WHERE id = ? AND status = 'pending' AND assignee IS NULL",
-    [claimerName, Date.now(), args.task_id]
-  )
-
-  if (result.changes === 0) {
-    throw new Error(`Task "${args.task_id}" is already claimed (race condition)`)
-  }
-
-  return `Claimed task: ${task.content}`
+  return `Claimed task: ${content}`
 }

package/src/tools/team-spawn.ts

@@ -1,6 +1,7 @@
 import type { ToolDeps, PermissionRule } from "../types"
 import { validateMemberName } from "../util"
 import { requireLead } from "./shared"
+import { claimTask } from "./team-claim"
 import { sendMessage } from "../messaging"
 import { log } from "../log"
 import type { EnsembleConfig } from "../config"
@@ -67,9 +68,14 @@ function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise
  */
 export async function executeTeamSpawn(
   deps: ToolDeps,
-  args: { name: string; agent: string; prompt: string; model?: string; claim_task?: string; worktree?: boolean; plan_approval?: boolean },
+  args: { name: string; agent?: string | null; prompt: string; model?: string; claim_task?: string; worktree?: boolean; plan_approval?: boolean },
   sessionId: string,
 ): Promise<string> {
+  // Normalize agent: the tool schema defaults to "build", but Zod's .default()
+  // only fires on undefined — an explicit null slips through and would violate
+  // the team_member.agent NOT NULL constraint (issue #28).
+  const agent = args.agent ?? "build"
+
   const nameError = validateMemberName(args.name)
   if (nameError) throw new Error(nameError)
 
@@ -86,11 +92,11 @@ export async function executeTeamSpawn(
     .get(teamInfo.teamId, args.name)
   if (existing) throw new Error(`Teammate "${args.name}" already exists in team "${teamInfo.teamName}"`)
 
-  const isReadOnly = args.agent === "plan" || args.agent === "explore"
+  const isReadOnly = agent === "plan" || agent === "explore"
   const useWorktree = args.worktree !== false && !isReadOnly && !isWorktreeDirectory(deps.directory)
   const usePlanApproval = args.plan_approval === true
 
-  log(`spawn:start name=${args.name} agent=${args.agent} worktree=${useWorktree}`)
+  log(`spawn:start name=${args.name} agent=${agent} worktree=${useWorktree}`)
 
   // Create worktree if enabled
   let worktreeDir: string | null = null
@@ -177,7 +183,7 @@ export async function executeTeamSpawn(
     const createResult = await withTimeout(
       deps.client.session.create({
         parentID: sessionId,
-        title: `${args.name} (@${args.agent} teammate)`,
+        title: `${args.name} (@${agent} teammate)`,
         permission,
         ...(workspaceId ? { workspaceID: workspaceId } : {}),
       }),
@@ -216,22 +222,37 @@ export async function executeTeamSpawn(
   const now = Date.now()
   // Resolve model before DB insert so the stored value matches what promptAsync uses
   const memberCount = (deps.db.query("SELECT COUNT(*) as c FROM team_member WHERE team_id = ?").get(teamInfo.teamId) as { c: number }).c
-  const resolvedModel = resolveModel(args.model, args.agent, memberCount, deps.config)
+  const resolvedModel = resolveModel(args.model, agent, memberCount, deps.config)
   if (resolvedModel) log(`spawn:model name=${args.name} model=${resolvedModel}`)
 
   deps.db.run(
     `INSERT INTO team_member (team_id, name, session_id, agent, status, execution_status, model, prompt, worktree_dir, worktree_branch, workspace_id, plan_approval, time_created, time_updated)
      VALUES (?, ?, ?, ?, 'busy', 'starting', ?, ?, ?, ?, ?, ?, ?, ?)`,
-    [teamInfo.teamId, args.name, childSessionId, args.agent, resolvedModel ?? null, args.prompt, worktreeDir, worktreeBranch, workspaceId, planApproval, now, now]
+    [teamInfo.teamId, args.name, childSessionId, agent, resolvedModel ?? null, args.prompt, worktreeDir, worktreeBranch, workspaceId, planApproval, now, now]
   )
 
   // Register in memory
   deps.registry.register(teamInfo.teamId, args.name, childSessionId)
 
+  // Auto-claim a task for this teammate when claim_task is provided (issue #27).
+  // Claims atomically so a task is never double-assigned when the lead hands out
+  // more tasks than there are teammates. Read-only agents cannot claim tasks.
+  let claimedTaskContent: string | null = null
+  let claimWarning: string | null = null
+  if (args.claim_task && !isReadOnly) {
+    try {
+      claimedTaskContent = claimTask(deps.db, teamInfo.teamId, args.claim_task, args.name)
+      log(`spawn:claim:ok name=${args.name} task=${args.claim_task}`)
+    } catch (err) {
+      claimWarning = err instanceof Error ? err.message : String(err)
+      log(`spawn:claim:failed name=${args.name} task=${args.claim_task} err=${claimWarning}`)
+    }
+  }
+
   // Build teammate context message
   const context = [
     `You are "${args.name}", a teammate in team "${teamInfo.teamName}".`,
-    `Your agent type is "${args.agent}".`,
+    `Your agent type is "${agent}".`,
   ]
 
   // Show other teammates so this agent knows who to message
@@ -347,7 +368,7 @@ export async function executeTeamSpawn(
     args.prompt,
   )
 
-  if (args.claim_task) {
+  if (claimedTaskContent) {
     context.push("", `You have been assigned task ${args.claim_task}. Mark it complete when done.`)
   }
 
@@ -364,7 +385,7 @@ export async function executeTeamSpawn(
   deps.client.session.promptAsync({
     sessionID: childSessionId,
     parts: [{ type: "text", text: contextStr }],
-    agent: args.agent,
+    agent,
     ...(modelParam ? { model: modelParam } : {}),
   }).catch((err) => {
     const errMsg = err instanceof Error ? err.message : String(err)
@@ -372,6 +393,13 @@ export async function executeTeamSpawn(
     try {
       deps.db.run("DELETE FROM team_member WHERE team_id = ? AND session_id = ?", [teamInfo.teamId, childSessionId])
       deps.registry.unregister(childSessionId)
+      // Release any task auto-claimed for this teammate so it returns to the pool.
+      if (claimedTaskContent) {
+        deps.db.run(
+          "UPDATE team_task SET status = 'pending', assignee = NULL, time_updated = ? WHERE id = ? AND assignee = ?",
+          [Date.now(), args.claim_task, args.name]
+        )
+      }
       deps.client.session.abort({ sessionID: childSessionId }).catch(() => { /* best effort */ })
       if (workspaceId) {
         deps.client.workspace.remove({ id: workspaceId }).catch(() => { /* best effort */ })
@@ -397,8 +425,11 @@ export async function executeTeamSpawn(
 
   const branchInfo = worktreeBranch ? ` (branch: ${worktreeBranch})` : ""
   const planInfo = usePlanApproval ? " [plan mode — will send plan for approval]" : ""
+  const claimInfo = claimedTaskContent
+    ? ` (claimed task: ${args.claim_task})`
+    : claimWarning ? ` (could not claim task: ${claimWarning})` : ""
   // Reset circuit breaker on success
   spawnFailures.delete(teamInfo.teamId)
   log(`spawn:done name=${args.name} sessionId=${childSessionId}`)
-  return `Teammate "${args.name}" spawned (agent: ${args.agent})${branchInfo}${planInfo}. They are working on: ${args.prompt.slice(0, 120)}${args.prompt.length > 120 ? "..." : ""}`
+  return `Teammate "${args.name}" spawned (agent: ${agent})${branchInfo}${planInfo}${claimInfo}. They are working on: ${args.prompt.slice(0, 120)}${args.prompt.length > 120 ? "..." : ""}`
 }

package/src/tools/team-tasks-complete.ts

@@ -5,6 +5,12 @@ import { log } from "../log"
 /**
  * Execute the team_tasks_complete tool. Marks a task as completed
  * and unblocks any dependent tasks.
+ *
+ * Enforces task-board accuracy (issue #27):
+ * - Rejects completing an already-completed or cancelled task.
+ * - Rejects completing a blocked task (dependencies must resolve first).
+ * - Only the assignee (or the lead) may complete a claimed task.
+ * - Completing an unclaimed task attributes it to the caller atomically.
  */
 export async function executeTeamTasksComplete(
   deps: ToolDeps,
@@ -12,13 +18,31 @@ export async function executeTeamTasksComplete(
   sessionId: string,
 ): Promise<string> {
   const teamInfo = requireTeamMember(deps, sessionId)
+  const caller = teamInfo.role === "lead" ? "lead" : (teamInfo.memberName ?? "unknown")
 
-  const task = deps.db.query("SELECT * FROM team_task WHERE id = ? AND team_id = ?")
-    .get(args.task_id, teamInfo.teamId) as Record<string, unknown> | null
+  const task = deps.db.query("SELECT id, content, status, assignee FROM team_task WHERE id = ? AND team_id = ?")
+    .get(args.task_id, teamInfo.teamId) as { id: string; content: string; status: string; assignee: string | null } | null
   if (!task) throw new Error(`Task "${args.task_id}" not found`)
+  if (task.status === "completed") throw new Error(`Task "${args.task_id}" is already completed`)
+  if (task.status === "cancelled") throw new Error(`Task "${args.task_id}" was cancelled`)
+  if (task.status === "blocked") throw new Error(`Task "${args.task_id}" is blocked by unresolved dependencies`)
+  if (task.status === "in_progress" && task.assignee && teamInfo.role !== "lead" && caller !== task.assignee) {
+    throw new Error(`Task "${args.task_id}" is claimed by ${task.assignee}`)
+  }
 
   const now = Date.now()
-  deps.db.run("UPDATE team_task SET status = 'completed', time_updated = ? WHERE id = ?", [now, args.task_id])
+  if (task.assignee) {
+    deps.db.run("UPDATE team_task SET status = 'completed', time_updated = ? WHERE id = ?", [now, args.task_id])
+  } else {
+    // Attribute an unclaimed task to the caller so the board reflects who did it.
+    const result = deps.db.run(
+      "UPDATE team_task SET status = 'completed', assignee = ?, time_updated = ? WHERE id = ? AND assignee IS NULL",
+      [caller, now, args.task_id]
+    )
+    if (result.changes === 0) {
+      throw new Error(`Task "${args.task_id}" was just completed by another teammate`)
+    }
+  }
 
   // Unblock dependent tasks
   const allTasks = deps.db.query("SELECT id, depends_on, status FROM team_task WHERE team_id = ?")

package/src/types.ts

@@ -50,6 +50,8 @@ export interface PluginClient {
     }): Promise<unknown>
     abort(options: { sessionID: string }): Promise<unknown>
     status(): Promise<{ data?: Record<string, { type: string }> }>
+    messages(options: { sessionID: string; limit?: number }): Promise<{ data?: Array<{ info: unknown; parts: unknown[] }> }>
+    get(options: { sessionID: string }): Promise<{ data?: unknown }>
   }
   tui: {
     showToast(options: {