@inixiative/hivemind 0.1.0

package/dist/plans/plans.test.js

@@ -0,0 +1,107 @@
+import { describe, it, expect, beforeEach, afterEach, afterAll } from 'bun:test';
+import { createTestDb, cleanupAllTestDbs } from '../test/setup';
+import { buildAgent, buildPlan } from '../test/factories';
+import { createPlan } from './createPlan';
+import { getPlan } from './getPlan';
+import { getActivePlans } from './getActivePlans';
+import { updatePlanStatus } from './updatePlanStatus';
+describe('Plans Module', () => {
+    let testDb;
+    beforeEach(() => {
+        testDb = createTestDb();
+    });
+    afterEach(() => {
+        testDb.cleanup();
+    });
+    afterAll(() => {
+        cleanupAllTestDbs();
+    });
+    describe('createPlan', () => {
+        it('creates a new plan', () => {
+            const { agent } = buildAgent(testDb.db, { label: 'test' });
+            const plan = createPlan(testDb.db, {
+                title: 'Implement Auth',
+                created_by: agent.id,
+            });
+            expect(plan.id).toMatch(/^pln_[a-f0-9]{6}$/);
+            expect(plan.title).toBe('Implement Auth');
+            expect(plan.status).toBe('active');
+            expect(plan.created_by).toBe(agent.id);
+        });
+        it('creates plan with label', () => {
+            const { agent } = buildAgent(testDb.db);
+            const plan = createPlan(testDb.db, {
+                title: 'Auth Feature',
+                label: 'auth',
+                created_by: agent.id,
+            });
+            expect(plan.id).toMatch(/^pln_[a-f0-9]{6}_auth$/);
+            expect(plan.label).toBe('auth');
+        });
+        it('creates plan with branch', () => {
+            const { agent } = buildAgent(testDb.db);
+            const plan = createPlan(testDb.db, {
+                title: 'Feature Work',
+                branch: 'feature/auth',
+                created_by: agent.id,
+            });
+            expect(plan.branch).toBe('feature/auth');
+        });
+        it('creates plan with description', () => {
+            const { agent } = buildAgent(testDb.db);
+            const plan = createPlan(testDb.db, {
+                title: 'Complex Feature',
+                description: 'This plan implements a complex feature with multiple tasks.',
+                created_by: agent.id,
+            });
+            expect(plan.description).toBe('This plan implements a complex feature with multiple tasks.');
+        });
+    });
+    describe('getPlan', () => {
+        it('retrieves existing plan', () => {
+            const { plan: created } = buildPlan(testDb.db, { title: 'Test Plan' });
+            const retrieved = getPlan(testDb.db, created.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.id).toBe(created.id);
+            expect(retrieved.title).toBe('Test Plan');
+        });
+        it('returns null for non-existent plan', () => {
+            const plan = getPlan(testDb.db, 'pln_nonexistent');
+            expect(plan).toBeNull();
+        });
+    });
+    describe('getActivePlans', () => {
+        it('returns only active plans', () => {
+            const { plan: plan1 } = buildPlan(testDb.db, { title: 'Active Plan' });
+            const { plan: plan2 } = buildPlan(testDb.db, { title: 'Completed Plan' });
+            updatePlanStatus(testDb.db, plan2.id, 'complete');
+            const active = getActivePlans(testDb.db);
+            expect(active).toHaveLength(1);
+            expect(active[0].id).toBe(plan1.id);
+        });
+        it('returns empty array when no active plans', () => {
+            const active = getActivePlans(testDb.db);
+            expect(active).toHaveLength(0);
+        });
+    });
+    describe('updatePlanStatus', () => {
+        it('updates plan to complete', () => {
+            const { plan } = buildPlan(testDb.db, { title: 'Test Plan' });
+            const success = updatePlanStatus(testDb.db, plan.id, 'complete');
+            expect(success).toBe(true);
+            const updated = getPlan(testDb.db, plan.id);
+            expect(updated.status).toBe('complete');
+        });
+        it('updates plan to paused', () => {
+            const { plan } = buildPlan(testDb.db, { title: 'Test Plan' });
+            const success = updatePlanStatus(testDb.db, plan.id, 'paused');
+            expect(success).toBe(true);
+            const updated = getPlan(testDb.db, plan.id);
+            expect(updated.status).toBe('paused');
+        });
+        it('returns false for non-existent plan', () => {
+            const result = updatePlanStatus(testDb.db, 'pln_nonexistent', 'complete');
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/plans/types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plan status values
+ */
+export type PlanStatus = 'active' | 'paused' | 'complete';
+/**
+ * Plan record as stored in DB
+ */
+export type Plan = {
+    id: string;
+    hex: string;
+    label: string | null;
+    title: string;
+    description: string | null;
+    status: PlanStatus;
+    branch: string | null;
+    worktree_id: string | null;
+    claude_session_id: string | null;
+    created_at: string;
+    created_by: string | null;
+};
+/**
+ * Input for creating a plan
+ */
+export type CreatePlanInput = {
+    title: string;
+    description?: string;
+    branch?: string;
+    worktree_id?: string;
+    claude_session_id?: string;
+    created_by?: string;
+    label?: string;
+};

package/dist/plans/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plans/updatePlanStatus.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { PlanStatus } from './types';
+/**
+ * Update a plan's status
+ */
+export declare function updatePlanStatus(db: Database, planId: string, status: PlanStatus): boolean;

package/dist/plans/updatePlanStatus.js

@@ -0,0 +1,8 @@
+/**
+ * Update a plan's status
+ */
+export function updatePlanStatus(db, planId, status) {
+    const stmt = db.prepare('UPDATE plans SET status = ? WHERE id = ?');
+    const result = stmt.run(status, planId);
+    return result.changes > 0;
+}

package/dist/tasks/assignTask.d.ts

@@ -0,0 +1,7 @@
+import type { Database } from 'bun:sqlite';
+import type { Task } from './types';
+/**
+ * Assign a task to an agent (force claim, even if already claimed)
+ * Use this when coordinating work - e.g., spawning a new agent for a task
+ */
+export declare function assignTask(db: Database, taskId: string, agentId: string): Task | null;

package/dist/tasks/assignTask.js

@@ -0,0 +1,20 @@
+import { now } from '../datetime/now';
+/**
+ * Assign a task to an agent (force claim, even if already claimed)
+ * Use this when coordinating work - e.g., spawning a new agent for a task
+ */
+export function assignTask(db, taskId, agentId) {
+    const timestamp = now();
+    const stmt = db.prepare(`
+    UPDATE tasks
+    SET status = 'claimed', claimed_by = ?, claimed_at = ?
+    WHERE id = ?
+  `);
+    const result = stmt.run(agentId, timestamp, taskId);
+    if (result.changes === 0) {
+        return null; // Task not found
+    }
+    // Return updated task
+    const getStmt = db.prepare('SELECT * FROM tasks WHERE id = ?');
+    return getStmt.get(taskId);
+}

package/dist/tasks/blockTask.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Mark a task as blocked
+ */
+export declare function blockTask(db: Database, taskId: string, reason?: string): boolean;

package/dist/tasks/blockTask.js

@@ -0,0 +1,12 @@
+/**
+ * Mark a task as blocked
+ */
+export function blockTask(db, taskId, reason) {
+    const stmt = db.prepare(`
+    UPDATE tasks
+    SET status = 'blocked'
+    WHERE id = ? AND status IN ('claimed', 'in_progress')
+  `);
+    const result = stmt.run(taskId);
+    return result.changes > 0;
+}

package/dist/tasks/claimTask.d.ts

@@ -0,0 +1,7 @@
+import type { Database } from 'bun:sqlite';
+import type { Task } from './types';
+/**
+ * Claim a task for an agent
+ * Returns the task if successful, null if already claimed or not found
+ */
+export declare function claimTask(db: Database, taskId: string, agentId: string): Task | null;

package/dist/tasks/claimTask.js

@@ -0,0 +1,21 @@
+import { now } from '../datetime/now';
+/**
+ * Claim a task for an agent
+ * Returns the task if successful, null if already claimed or not found
+ */
+export function claimTask(db, taskId, agentId) {
+    const timestamp = now();
+    // Try to claim (only if pending)
+    const stmt = db.prepare(`
+    UPDATE tasks
+    SET status = 'claimed', claimed_by = ?, claimed_at = ?
+    WHERE id = ? AND status = 'pending'
+  `);
+    const result = stmt.run(agentId, timestamp, taskId);
+    if (result.changes === 0) {
+        return null; // Already claimed or not found
+    }
+    // Return updated task
+    const getStmt = db.prepare('SELECT * FROM tasks WHERE id = ?');
+    return getStmt.get(taskId);
+}

package/dist/tasks/completeTask.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Task } from './types';
+/**
+ * Mark a task as complete with an outcome
+ */
+export declare function completeTask(db: Database, taskId: string, outcome?: string): Task | null;

package/dist/tasks/completeTask.js

@@ -0,0 +1,18 @@
+import { now } from '../datetime/now';
+/**
+ * Mark a task as complete with an outcome
+ */
+export function completeTask(db, taskId, outcome) {
+    const timestamp = now();
+    const stmt = db.prepare(`
+    UPDATE tasks
+    SET status = 'done', completed_at = ?, outcome = ?
+    WHERE id = ? AND status IN ('claimed', 'in_progress')
+  `);
+    const result = stmt.run(timestamp, outcome ?? null, taskId);
+    if (result.changes === 0) {
+        return null;
+    }
+    const getStmt = db.prepare('SELECT * FROM tasks WHERE id = ?');
+    return getStmt.get(taskId);
+}

package/dist/tasks/createTask.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Task, CreateTaskInput } from './types';
+/**
+ * Create a new task in a plan
+ */
+export declare function createTask(db: Database, input: CreateTaskInput): Task;

package/dist/tasks/createTask.js

@@ -0,0 +1,36 @@
+import { makeTaskId } from '../ids/makeTaskId';
+import { parseId } from '../ids/parseId';
+import { nextTaskSeq } from '../db/nextTaskSeq';
+/**
+ * Create a new task in a plan
+ */
+export function createTask(db, input) {
+    // Get plan hex from plan ID
+    const planParsed = parseId(input.plan_id);
+    const seq = nextTaskSeq(db, input.plan_id);
+    const seqStr = String(seq).padStart(3, '0');
+    const id = makeTaskId(planParsed.hex, seq, input.label);
+    const parsed = parseId(id);
+    const stmt = db.prepare(`
+    INSERT INTO tasks (id, plan_hex, seq, label, plan_id, title, description, status, branch, worktree_id, parent_task_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?)
+  `);
+    stmt.run(id, planParsed.hex, seqStr, parsed.label ?? null, input.plan_id, input.title, input.description ?? null, input.branch ?? null, input.worktree_id ?? null, input.parent_task_id ?? null);
+    return {
+        id,
+        plan_hex: planParsed.hex,
+        seq: seqStr,
+        label: parsed.label ?? null,
+        plan_id: input.plan_id,
+        title: input.title,
+        description: input.description ?? null,
+        status: 'pending',
+        branch: input.branch ?? null,
+        worktree_id: input.worktree_id ?? null,
+        claimed_by: null,
+        claimed_at: null,
+        completed_at: null,
+        outcome: null,
+        parent_task_id: input.parent_task_id ?? null,
+    };
+}

package/dist/tasks/getPendingTasks.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Task } from './types';
+/**
+ * Get all pending (unclaimed) tasks, optionally filtered by plan
+ */
+export declare function getPendingTasks(db: Database, planId?: string): Task[];

package/dist/tasks/getPendingTasks.js

@@ -0,0 +1,19 @@
+/**
+ * Get all pending (unclaimed) tasks, optionally filtered by plan
+ */
+export function getPendingTasks(db, planId) {
+    if (planId) {
+        const stmt = db.prepare(`
+      SELECT * FROM tasks
+      WHERE plan_id = ? AND status = 'pending'
+      ORDER BY seq ASC
+    `);
+        return stmt.all(planId);
+    }
+    const stmt = db.prepare(`
+    SELECT * FROM tasks
+    WHERE status = 'pending'
+    ORDER BY plan_id, seq ASC
+  `);
+    return stmt.all();
+}

package/dist/tasks/getTask.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Task } from './types';
+/**
+ * Get a task by ID
+ */
+export declare function getTask(db: Database, taskId: string): Task | null;

package/dist/tasks/getTask.js

@@ -0,0 +1,7 @@
+/**
+ * Get a task by ID
+ */
+export function getTask(db, taskId) {
+    const stmt = db.prepare('SELECT * FROM tasks WHERE id = ?');
+    return stmt.get(taskId) ?? null;
+}

package/dist/tasks/getTasksByPlan.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Task } from './types';
+/**
+ * Get all tasks for a plan
+ */
+export declare function getTasksByPlan(db: Database, planId: string): Task[];

package/dist/tasks/getTasksByPlan.js

@@ -0,0 +1,11 @@
+/**
+ * Get all tasks for a plan
+ */
+export function getTasksByPlan(db, planId) {
+    const stmt = db.prepare(`
+    SELECT * FROM tasks
+    WHERE plan_id = ?
+    ORDER BY seq ASC
+  `);
+    return stmt.all(planId);
+}

package/dist/tasks/index.d.ts

@@ -0,0 +1,11 @@
+export type { TaskStatus, Task, CreateTaskInput } from './types';
+export { createTask } from './createTask';
+export { getTask } from './getTask';
+export { getTasksByPlan } from './getTasksByPlan';
+export { getPendingTasks } from './getPendingTasks';
+export { claimTask } from './claimTask';
+export { assignTask } from './assignTask';
+export { unclaimTask } from './unclaimTask';
+export { startTask } from './startTask';
+export { completeTask } from './completeTask';
+export { blockTask } from './blockTask';

package/dist/tasks/index.js

@@ -0,0 +1,12 @@
+// CRUD
+export { createTask } from './createTask';
+export { getTask } from './getTask';
+export { getTasksByPlan } from './getTasksByPlan';
+export { getPendingTasks } from './getPendingTasks';
+// Workflow
+export { claimTask } from './claimTask';
+export { assignTask } from './assignTask';
+export { unclaimTask } from './unclaimTask';
+export { startTask } from './startTask';
+export { completeTask } from './completeTask';
+export { blockTask } from './blockTask';

package/dist/tasks/startTask.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Mark a task as in_progress
+ */
+export declare function startTask(db: Database, taskId: string): boolean;

package/dist/tasks/startTask.js

@@ -0,0 +1,12 @@
+/**
+ * Mark a task as in_progress
+ */
+export function startTask(db, taskId) {
+    const stmt = db.prepare(`
+    UPDATE tasks
+    SET status = 'in_progress'
+    WHERE id = ? AND status = 'claimed'
+  `);
+    const result = stmt.run(taskId);
+    return result.changes > 0;
+}

package/dist/tasks/tasks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tasks/tasks.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, afterEach, afterAll } from 'bun:test';
+import { createTestDb, cleanupAllTestDbs } from '../test/setup';
+import { buildAgent, buildPlan, buildTask } from '../test/factories';
+import { createTask } from './createTask';
+import { getTask } from './getTask';
+import { getTasksByPlan } from './getTasksByPlan';
+import { getPendingTasks } from './getPendingTasks';
+import { claimTask } from './claimTask';
+import { assignTask } from './assignTask';
+import { unclaimTask } from './unclaimTask';
+import { startTask } from './startTask';
+import { completeTask } from './completeTask';
+import { blockTask } from './blockTask';
+describe('Tasks Module', () => {
+    let testDb;
+    beforeEach(() => {
+        testDb = createTestDb();
+    });
+    afterEach(() => {
+        testDb.cleanup();
+    });
+    afterAll(() => {
+        cleanupAllTestDbs();
+    });
+    describe('createTask', () => {
+        it('creates a task with auto-generated seq', () => {
+            const { plan } = buildPlan(testDb.db);
+            const task = createTask(testDb.db, {
+                plan_id: plan.id,
+                title: 'Implement login',
+            });
+            expect(task.id).toBe(`tsk_${plan.hex}_001`);
+            expect(task.title).toBe('Implement login');
+            expect(task.status).toBe('pending');
+            expect(task.plan_id).toBe(plan.id);
+        });
+        it('increments sequence for multiple tasks', () => {
+            const { plan } = buildPlan(testDb.db);
+            const task1 = createTask(testDb.db, { plan_id: plan.id, title: 'Task 1' });
+            const task2 = createTask(testDb.db, { plan_id: plan.id, title: 'Task 2' });
+            const task3 = createTask(testDb.db, { plan_id: plan.id, title: 'Task 3' });
+            expect(task1.seq).toBe('001');
+            expect(task2.seq).toBe('002');
+            expect(task3.seq).toBe('003');
+        });
+        it('creates task with label', () => {
+            const { plan } = buildPlan(testDb.db);
+            const task = createTask(testDb.db, {
+                plan_id: plan.id,
+                title: 'Setup Database',
+                label: 'setup',
+            });
+            expect(task.id).toBe(`tsk_${plan.hex}_001_setup`);
+            expect(task.label).toBe('setup');
+        });
+        it('creates task with description', () => {
+            const { plan } = buildPlan(testDb.db);
+            const task = createTask(testDb.db, {
+                plan_id: plan.id,
+                title: 'Complex Task',
+                description: 'This task requires multiple steps.',
+            });
+            expect(task.description).toBe('This task requires multiple steps.');
+        });
+        it('creates task with branch', () => {
+            const { plan } = buildPlan(testDb.db);
+            const task = createTask(testDb.db, {
+                plan_id: plan.id,
+                title: 'Feature Task',
+                branch: 'feature/specific',
+            });
+            expect(task.branch).toBe('feature/specific');
+        });
+    });
+    describe('getTask', () => {
+        it('retrieves existing task', () => {
+            const { task: created } = buildTask(testDb.db, { title: 'Test Task' });
+            const retrieved = getTask(testDb.db, created.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.id).toBe(created.id);
+            expect(retrieved.title).toBe('Test Task');
+        });
+        it('returns null for non-existent task', () => {
+            const task = getTask(testDb.db, 'tsk_nonexistent_01');
+            expect(task).toBeNull();
+        });
+    });
+    describe('getTasksByPlan', () => {
+        it('returns all tasks for plan', () => {
+            const { plan } = buildPlan(testDb.db);
+            buildTask(testDb.db, { plan, title: 'Task 1' });
+            buildTask(testDb.db, { plan, title: 'Task 2' });
+            buildTask(testDb.db, { plan, title: 'Task 3' });
+            const tasks = getTasksByPlan(testDb.db, plan.id);
+            expect(tasks).toHaveLength(3);
+        });
+        it('returns tasks in sequence order', () => {
+            const { plan } = buildPlan(testDb.db);
+            buildTask(testDb.db, { plan, title: 'First' });
+            buildTask(testDb.db, { plan, title: 'Second' });
+            buildTask(testDb.db, { plan, title: 'Third' });
+            const tasks = getTasksByPlan(testDb.db, plan.id);
+            expect(tasks[0].title).toBe('First');
+            expect(tasks[1].title).toBe('Second');
+            expect(tasks[2].title).toBe('Third');
+        });
+    });
+    describe('getPendingTasks', () => {
+        it('returns only pending tasks', () => {
+            const { agent } = buildAgent(testDb.db, { label: 'test' });
+            const { plan } = buildPlan(testDb.db, { agent });
+            const { task: task1 } = buildTask(testDb.db, { plan, title: 'Pending' });
+            const { task: task2 } = buildTask(testDb.db, { plan, title: 'To be claimed' });
+            // Claim task2 so it's no longer pending
+            claimTask(testDb.db, task2.id, agent.id);
+            const pending = getPendingTasks(testDb.db);
+            expect(pending).toHaveLength(1);
+            expect(pending[0].id).toBe(task1.id);
+        });
+    });
+    describe('claimTask', () => {
+        it('claims task for agent', () => {
+            const { agent } = buildAgent(testDb.db);
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            const claimed = claimTask(testDb.db, task.id, agent.id);
+            expect(claimed).toBeDefined();
+            expect(claimed.claimed_by).toBe(agent.id);
+            expect(claimed.claimed_at).toBeDefined();
+        });
+        it('returns null if task already claimed', () => {
+            const { agent: agent1 } = buildAgent(testDb.db, { label: 'one' });
+            const { agent: agent2 } = buildAgent(testDb.db, { label: 'two' });
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            claimTask(testDb.db, task.id, agent1.id);
+            const result = claimTask(testDb.db, task.id, agent2.id);
+            expect(result).toBeNull();
+        });
+    });
+    describe('assignTask', () => {
+        it('assigns task to agent (even if claimed)', () => {
+            const { agent: agent1 } = buildAgent(testDb.db, { label: 'one' });
+            const { agent: agent2 } = buildAgent(testDb.db, { label: 'two' });
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            claimTask(testDb.db, task.id, agent1.id);
+            const assigned = assignTask(testDb.db, task.id, agent2.id);
+            expect(assigned).toBeDefined();
+            expect(assigned.claimed_by).toBe(agent2.id);
+        });
+    });
+    describe('unclaimTask', () => {
+        it('releases task claim', () => {
+            const { agent } = buildAgent(testDb.db);
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            claimTask(testDb.db, task.id, agent.id);
+            const success = unclaimTask(testDb.db, task.id);
+            expect(success).toBe(true);
+            // Verify the task was updated
+            const updated = getTask(testDb.db, task.id);
+            expect(updated.claimed_by).toBeNull();
+            expect(updated.claimed_at).toBeNull();
+            expect(updated.status).toBe('pending');
+        });
+    });
+    describe('startTask', () => {
+        it('changes status to in_progress', () => {
+            const { agent } = buildAgent(testDb.db);
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            // Must claim first since startTask requires 'claimed' status
+            claimTask(testDb.db, task.id, agent.id);
+            const success = startTask(testDb.db, task.id);
+            expect(success).toBe(true);
+            // Verify the task was updated
+            const updated = getTask(testDb.db, task.id);
+            expect(updated.status).toBe('in_progress');
+        });
+    });
+    describe('completeTask', () => {
+        it('changes status to done', () => {
+            const { agent } = buildAgent(testDb.db);
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            // Must claim first since completeTask requires 'claimed' or 'in_progress'
+            claimTask(testDb.db, task.id, agent.id);
+            const completed = completeTask(testDb.db, task.id);
+            expect(completed).toBeDefined();
+            expect(completed.status).toBe('done');
+            expect(completed.completed_at).toBeDefined();
+        });
+        it('stores outcome', () => {
+            const { agent } = buildAgent(testDb.db);
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            claimTask(testDb.db, task.id, agent.id);
+            const completed = completeTask(testDb.db, task.id, 'Successfully implemented');
+            expect(completed.outcome).toBe('Successfully implemented');
+        });
+    });
+    describe('blockTask', () => {
+        it('changes status to blocked', () => {
+            const { agent } = buildAgent(testDb.db);
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            // Must claim first since blockTask requires 'claimed' or 'in_progress'
+            claimTask(testDb.db, task.id, agent.id);
+            const success = blockTask(testDb.db, task.id, 'Waiting for API');
+            expect(success).toBe(true);
+            // Verify the task was updated
+            const updated = getTask(testDb.db, task.id);
+            expect(updated.status).toBe('blocked');
+        });
+    });
+});