@hueyexe/opencode-ensemble 0.16.0 → 0.16.1

package/dist/index.js

@@ -19773,6 +19773,30 @@ function requireCanPurgeArchivedTeams(deps, sessionId) {
   }
 }
 
+// src/tools/team-claim.ts
+function claimTask(db, teamId, taskId, assignee) {
+  const task = db.query("SELECT content, status, assignee FROM team_task WHERE id = ? AND team_id = ?").get(taskId, teamId);
+  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}`);
+  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;
+}
+async function executeTeamClaim(deps, args, sessionId) {
+  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);
+  return `Claimed task: ${content}`;
+}
+
 // src/tools/team-spawn.ts
 init_merge_helper();
 var spawnFailures = new Map;
@@ -19813,6 +19837,7 @@ function withTimeout(promise2, ms, label) {
   ]);
 }
 async function executeTeamSpawn(deps, args, sessionId) {
+  const agent = args.agent ?? "build";
   const nameError = validateMemberName(args.name);
   if (nameError)
     throw new Error(nameError);
@@ -19824,10 +19849,10 @@ async function executeTeamSpawn(deps, args, sessionId) {
   const existing = deps.db.query("SELECT name FROM team_member WHERE team_id = ? AND name = ?").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}`);
   let worktreeDir = null;
   let worktreeBranch = null;
   if (useWorktree) {
@@ -19883,7 +19908,7 @@ async function executeTeamSpawn(deps, args, sessionId) {
     log(`spawn:session:start name=${args.name}`);
     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 } : {}
     }), getSpawnTimeout(), `session.create for "${args.name}"`);
@@ -19922,15 +19947,26 @@ async function executeTeamSpawn(deps, args, sessionId) {
   const planApproval = usePlanApproval ? "pending" : "none";
   const now = Date.now();
   const memberCount = deps.db.query("SELECT COUNT(*) as c FROM team_member WHERE team_id = ?").get(teamInfo.teamId).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]);
+     VALUES (?, ?, ?, ?, 'busy', 'starting', ?, ?, ?, ?, ?, ?, ?, ?)`, [teamInfo.teamId, args.name, childSessionId, agent, resolvedModel ?? null, args.prompt, worktreeDir, worktreeBranch, workspaceId, planApproval, now, now]);
   deps.registry.register(teamInfo.teamId, args.name, childSessionId);
+  let claimedTaskContent = null;
+  let claimWarning = 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}`);
+    }
+  }
   const context = [
     `You are "${args.name}", a teammate in team "${teamInfo.teamName}".`,
-    `Your agent type is "${args.agent}".`
+    `Your agent type is "${agent}".`
   ];
   const otherMembers = deps.db.query("SELECT name FROM team_member WHERE team_id = ? AND name != ? AND status NOT IN ('shutdown', 'error')").all(teamInfo.teamId, args.name);
   if (otherMembers.length > 0) {
@@ -19973,7 +20009,7 @@ async function executeTeamSpawn(deps, args, sessionId) {
   const lastStep = !isReadOnly && worktreeBranch ? "4" : !isReadOnly ? "3" : "2";
   context.push(`${lastStep}. STOP. Do not send follow-up confirmations, status updates, or 'standing by' messages.`, "", "If you are blocked:", "- Send ONE message to the lead via team_message describing the specific blocker.", "- Do NOT attempt workarounds or make assumptions. Wait for the lead's response.", "", "Your plain text output is NOT visible to the team. You MUST use team_message to communicate.");
   context.push("", "Your task:", args.prompt);
-  if (args.claim_task) {
+  if (claimedTaskContent) {
     context.push("", `You have been assigned task ${args.claim_task}. Mark it complete when done.`);
   }
   const contextStr = context.join(`
@@ -19986,7 +20022,7 @@ async function executeTeamSpawn(deps, args, sessionId) {
   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);
@@ -19994,6 +20030,9 @@ async function executeTeamSpawn(deps, args, sessionId) {
     try {
       deps.db.run("DELETE FROM team_member WHERE team_id = ? AND session_id = ?", [teamInfo.teamId, childSessionId]);
       deps.registry.unregister(childSessionId);
+      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(() => {});
       if (workspaceId) {
         deps.client.workspace.remove({ id: workspaceId }).catch(() => {});
@@ -20018,9 +20057,10 @@ async function executeTeamSpawn(deps, args, sessionId) {
   });
   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})` : "";
   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 ? "..." : ""}`;
 }
 
 // src/tools/team-message.ts
@@ -20754,11 +20794,28 @@ async function executeTeamTasksAdd(deps, args, sessionId) {
 // src/tools/team-tasks-complete.ts
 async function executeTeamTasksComplete(deps, args, sessionId) {
   const teamInfo = requireTeamMember(deps, sessionId);
-  const task = deps.db.query("SELECT * FROM team_task WHERE id = ? AND team_id = ?").get(args.task_id, teamInfo.teamId);
+  const caller = teamInfo.role === "lead" ? "lead" : teamInfo.memberName ?? "unknown";
+  const task = deps.db.query("SELECT id, content, status, assignee FROM team_task WHERE id = ? AND team_id = ?").get(args.task_id, teamInfo.teamId);
   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 {
+    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`);
+    }
+  }
   const allTasks = deps.db.query("SELECT id, depends_on, status FROM team_task WHERE team_id = ?").all(teamInfo.teamId);
   let unblocked = 0;
   for (const t of allTasks) {
@@ -20796,26 +20853,6 @@ async function executeTeamTasksComplete(deps, args, sessionId) {
   return `Completed task: ${task.content}${unblockedMsg}`;
 }
 
-// src/tools/team-claim.ts
-async function executeTeamClaim(deps, args, sessionId) {
-  const teamInfo = requireTeamMember(deps, sessionId);
-  const claimerName = 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);
-  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}`);
-  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}`;
-}
-
 // src/tools/team-results.ts
 async function executeTeamResults(deps, args, sessionId) {
   const team = requireTeamMember(deps, sessionId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hueyexe/opencode-ensemble",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Agent teams for OpenCode — parallel agents with peer-to-peer communication, shared tasks, and coordinated execution",
   "module": "src/index.ts",
   "main": "dist/index.js",

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 = ?")