aitasks 1.4.0 → 1.4.2

package/dist/index.js

@@ -1890,7 +1890,7 @@ var require_commander = __commonJS((exports) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "aitasks",
-    version: "1.4.0",
+    version: "1.4.2",
     description: "CLI task management tool built for AI agents",
     type: "module",
     bin: {
@@ -29071,7 +29071,7 @@ import { join as join3 } from "path";
 import { existsSync as existsSync3 } from "fs";
 
 // src/db/schema.ts
-var SCHEMA_VERSION = 3;
+var SCHEMA_VERSION = 4;
 function runMigrations(db) {
   const row = db.query(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
   const current = row ? parseInt(row.value, 10) : 1;
@@ -29085,6 +29085,12 @@ function runMigrations(db) {
     db.exec(`UPDATE agents SET first_seen = last_seen WHERE first_seen IS NULL`);
     db.exec(`UPDATE meta SET value = '3' WHERE key = 'schema_version'`);
   }
+  if (current < 4) {
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_events_task_created ON events(task_id, created_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_agents_current_task ON agents(current_task)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_type ON tasks(type)`);
+    db.exec(`UPDATE meta SET value = '4' WHERE key = 'schema_version'`);
+  }
 }
 function initializeSchema(db) {
   db.exec(`
@@ -29134,8 +29140,11 @@ function initializeSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_tasks_priority    ON tasks(priority);
     CREATE INDEX IF NOT EXISTS idx_tasks_assigned_to ON tasks(assigned_to);
     CREATE INDEX IF NOT EXISTS idx_tasks_parent_id   ON tasks(parent_id);
-    CREATE INDEX IF NOT EXISTS idx_events_task_id    ON events(task_id);
-    CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at);
+    CREATE INDEX IF NOT EXISTS idx_events_task_id      ON events(task_id);
+    CREATE INDEX IF NOT EXISTS idx_events_created_at  ON events(created_at);
+    CREATE INDEX IF NOT EXISTS idx_events_task_created ON events(task_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_agents_current_task ON agents(current_task);
+    CREATE INDEX IF NOT EXISTS idx_tasks_type          ON tasks(type);
   `);
   const insert = db.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES (?, ?)`);
   insert.run("last_task_number", "0");
@@ -30214,29 +30223,82 @@ var be = async (s, n) => {
 };
 
 // src/models/event.ts
-function logEvent(data) {
+var _stmtDb = null;
+var _insertEvent = null;
+var _selectTaskEvents = null;
+var _selectAllEvents = null;
+var _selectLastReviewEvent = null;
+function stmts() {
   const db = getDb();
-  db.run(`INSERT INTO events (task_id, agent_id, event_type, payload, created_at)
-     VALUES (?, ?, ?, ?, ?)`, [
-    data.task_id,
-    data.agent_id ?? null,
-    data.event_type,
-    JSON.stringify(data.payload ?? {}),
-    Date.now()
-  ]);
+  if (_stmtDb !== db) {
+    _stmtDb = db;
+    _insertEvent = db.query(`INSERT INTO events (task_id, agent_id, event_type, payload, created_at)
+       VALUES (?, ?, ?, ?, ?)`);
+    _selectTaskEvents = db.query("SELECT * FROM events WHERE task_id = ? ORDER BY created_at ASC");
+    _selectAllEvents = db.query("SELECT * FROM events ORDER BY created_at DESC LIMIT ?");
+    _selectLastReviewEvent = db.query(`SELECT * FROM events WHERE task_id = ? AND event_type = 'review_requested'
+       ORDER BY created_at DESC LIMIT 1`);
+  }
+  return { _insertEvent, _selectTaskEvents, _selectAllEvents, _selectLastReviewEvent };
+}
+function parseEvent(r2) {
+  return { ...r2, payload: JSON.parse(r2.payload) };
+}
+function logEvent(data) {
+  stmts()._insertEvent.run(data.task_id, data.agent_id ?? null, data.event_type, JSON.stringify(data.payload ?? {}), Date.now());
 }
 function getTaskEvents(taskId) {
-  const db = getDb();
-  const rows = db.query("SELECT * FROM events WHERE task_id = ? ORDER BY created_at ASC").all(taskId);
-  return rows.map((r2) => ({ ...r2, payload: JSON.parse(r2.payload) }));
+  const rows = stmts()._selectTaskEvents.all(taskId);
+  return rows.map(parseEvent);
+}
+function getLastReviewEvent(taskId) {
+  const row = stmts()._selectLastReviewEvent.get(taskId);
+  return row ? parseEvent(row) : null;
 }
 function getAllEvents(limit = 100) {
-  const db = getDb();
-  const rows = db.query("SELECT * FROM events ORDER BY created_at DESC LIMIT ?").all(limit);
-  return rows.map((r2) => ({ ...r2, payload: JSON.parse(r2.payload) }));
+  const rows = stmts()._selectAllEvents.all(limit);
+  return rows.map(parseEvent);
 }
 
 // src/models/task.ts
+var _stmtDb2 = null;
+var _getTaskStmt = null;
+var _getAllIdsStmt = null;
+var _getMetaStmt = null;
+var _updateMetaStmt = null;
+var _upsertAgentStmt = null;
+var _heartbeatStmt = null;
+var _releaseAgentStmt = null;
+var _subtaskCountStmt = null;
+function stmts2() {
+  const db = getDb();
+  if (_stmtDb2 !== db) {
+    _stmtDb2 = db;
+    _getTaskStmt = db.query("SELECT * FROM tasks WHERE id = ?");
+    _getAllIdsStmt = db.query("SELECT id FROM tasks");
+    _getMetaStmt = db.query(`SELECT value FROM meta WHERE key = 'last_task_number'`);
+    _updateMetaStmt = db.query(`UPDATE meta SET value = ? WHERE key = 'last_task_number'`);
+    _upsertAgentStmt = db.query(`INSERT INTO agents (id, first_seen, last_seen, current_task)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET last_seen = excluded.last_seen, current_task = excluded.current_task`);
+    _heartbeatStmt = db.query(`INSERT INTO agents (id, first_seen, last_seen, current_task)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET last_seen = excluded.last_seen`);
+    _releaseAgentStmt = db.query(`UPDATE agents SET current_task = NULL WHERE id = ?`);
+    _subtaskCountStmt = db.query(`SELECT COUNT(*) as count FROM tasks WHERE parent_id = ?`);
+  }
+  return {
+    db,
+    getTask: _getTaskStmt,
+    getAllIds: _getAllIdsStmt,
+    getMeta: _getMetaStmt,
+    updateMeta: _updateMetaStmt,
+    upsertAgent: _upsertAgentStmt,
+    heartbeat: _heartbeatStmt,
+    releaseAgent: _releaseAgentStmt,
+    subtaskCount: _subtaskCountStmt
+  };
+}
 function parseTask(row) {
   return {
     id: row.id,
@@ -30260,17 +30322,20 @@ function parseTask(row) {
   };
 }
 function nextTaskId() {
-  const db = getDb();
-  const meta = db.query(`SELECT value FROM meta WHERE key = 'last_task_number'`).get();
+  const s = stmts2();
+  const meta = s.getMeta.get();
   const next = parseInt(meta.value, 10) + 1;
-  db.run(`UPDATE meta SET value = ? WHERE key = 'last_task_number'`, [String(next)]);
+  s.updateMeta.run(String(next));
   return `TASK-${String(next).padStart(3, "0")}`;
 }
 function getTask(id) {
-  const db = getDb();
-  const row = db.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  const row = stmts2().getTask.get(id);
   return row ? parseTask(row) : null;
 }
+function getAllTaskIds() {
+  const rows = stmts2().getAllIds.all();
+  return rows.map((r2) => r2.id);
+}
 var PRIORITY_ORDER = `CASE priority
   WHEN 'critical' THEN 0
   WHEN 'high'     THEN 1
@@ -30284,7 +30349,7 @@ var STATUS_ORDER = `CASE status
   WHEN 'backlog'      THEN 4
   WHEN 'done'         THEN 5 END`;
 function listTasks(filters = {}) {
-  const db = getDb();
+  const db = stmts2().db;
   const conds = [];
   const params = [];
   if (filters.status) {
@@ -30329,8 +30394,25 @@ function listTasks(filters = {}) {
 function getSubtasks(parentId) {
   return listTasks({ parent_id: parentId });
 }
+function searchTasks(terms, status) {
+  const db = stmts2().db;
+  const conds = [];
+  const params = [];
+  if (status) {
+    conds.push("status = ?");
+    params.push(status);
+  }
+  for (const term of terms) {
+    conds.push(`(title LIKE ? OR description LIKE ? OR implementation_notes LIKE ? OR acceptance_criteria LIKE ?)`);
+    const like = `%${term}%`;
+    params.push(like, like, like, like);
+  }
+  const where = conds.length > 0 ? `WHERE ${conds.join(" AND ")}` : "";
+  const rows = db.query(`SELECT * FROM tasks ${where}`).all(...params);
+  return rows.map(parseTask);
+}
 function createTask(data) {
-  const db = getDb();
+  const db = stmts2().db;
   const id = nextTaskId();
   const now = Date.now();
   db.run(`INSERT INTO tasks
@@ -30361,7 +30443,7 @@ var JSON_FIELDS = new Set([
   "metadata"
 ]);
 function updateTask(id, updates) {
-  const db = getDb();
+  const db = stmts2().db;
   const fields = ["updated_at = ?"];
   const params = [Date.now()];
   for (const [key, value] of Object.entries(updates)) {
@@ -30371,8 +30453,8 @@ function updateTask(id, updates) {
     params.push(JSON_FIELDS.has(key) ? JSON.stringify(value) : value);
   }
   params.push(id);
-  db.run(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ?`, params);
-  return getTask(id);
+  const row = db.query(`UPDATE tasks SET ${fields.join(", ")} WHERE id = ? RETURNING *`).get(...params);
+  return row ? parseTask(row) : null;
 }
 function addImplementationNote(taskId, note, agentId) {
   const task = getTask(taskId);
@@ -30420,7 +30502,7 @@ function checkCriterion(taskId, index, evidence, agentId) {
   return { task: updated };
 }
 function claimTask(taskId, agentId) {
-  const db = getDb();
+  const s = stmts2();
   const task = getTask(taskId);
   if (!task)
     return { task: null, error: "Task not found" };
@@ -30435,14 +30517,14 @@ function claimTask(taskId, agentId) {
       error: `Task is blocked by: ${task.blocked_by.join(", ")}. Complete those first.`
     };
   }
-  db.run(`INSERT INTO agents (id, first_seen, last_seen, current_task)
-     VALUES (?, ?, ?, ?)
-     ON CONFLICT(id) DO UPDATE SET last_seen = excluded.last_seen, current_task = excluded.current_task`, [agentId, Date.now(), Date.now(), taskId]);
+  const now = Date.now();
+  s.upsertAgent.run(agentId, now, now, taskId);
   const updated = updateTask(taskId, { assigned_to: agentId, status: "ready" });
   logEvent({ task_id: taskId, agent_id: agentId, event_type: "claimed", payload: {} });
   return { task: updated };
 }
 function startTask(taskId, agentId) {
+  const s = stmts2();
   const task = getTask(taskId);
   if (!task)
     return { task: null, error: "Task not found" };
@@ -30451,11 +30533,9 @@ function startTask(taskId, agentId) {
   if (task.assigned_to && task.assigned_to !== agentId) {
     return { task: null, error: `Task is assigned to ${task.assigned_to}, not ${agentId}` };
   }
-  const db = getDb();
   if (!task.assigned_to) {
-    db.run(`INSERT INTO agents (id, first_seen, last_seen, current_task)
-       VALUES (?, ?, ?, ?)
-       ON CONFLICT(id) DO UPDATE SET last_seen = excluded.last_seen, current_task = excluded.current_task`, [agentId, Date.now(), Date.now(), taskId]);
+    const now = Date.now();
+    s.upsertAgent.run(agentId, now, now, taskId);
   }
   const updated = updateTask(taskId, {
     assigned_to: agentId,
@@ -30466,7 +30546,7 @@ function startTask(taskId, agentId) {
   return { task: updated };
 }
 function completeTask(taskId, agentId) {
-  const db = getDb();
+  const s = stmts2();
   const task = getTask(taskId);
   if (!task)
     return { task: null, error: "Task not found" };
@@ -30498,8 +30578,7 @@ function completeTask(taskId, agentId) {
 ` + `  A separate review sub-agent must run: aitasks done ${taskId} --agent <review-agent-id>`
       };
     }
-    const events = getTaskEvents(taskId);
-    const reviewEvent = [...events].reverse().find((e2) => e2.event_type === "review_requested");
+    const reviewEvent = getLastReviewEvent(taskId);
     if (reviewEvent?.agent_id && reviewEvent.agent_id === agentId) {
       return {
         task: null,
@@ -30508,69 +30587,87 @@ function completeTask(taskId, agentId) {
       };
     }
   }
-  const updated = updateTask(taskId, { status: "done", completed_at: Date.now() });
-  logEvent({ task_id: taskId, agent_id: agentId, event_type: "completed", payload: {} });
-  const pendingRows = db.query(`SELECT id, blocked_by FROM tasks WHERE status != 'done'`).all();
-  for (const row of pendingRows) {
-    const blockedBy = JSON.parse(row.blocked_by);
-    if (!blockedBy.includes(taskId))
-      continue;
-    const remaining = blockedBy.filter((id) => id !== taskId);
-    const newStatus = remaining.length === 0 ? "ready" : "blocked";
-    db.run(`UPDATE tasks SET blocked_by = ?, status = ?, updated_at = ? WHERE id = ?`, [JSON.stringify(remaining), newStatus, Date.now(), row.id]);
-    if (newStatus === "ready") {
-      logEvent({
-        task_id: row.id,
-        event_type: "auto_unblocked",
-        payload: { unblocked_by: taskId }
-      });
+  const db = s.db;
+  const doComplete = db.transaction(() => {
+    const updated2 = updateTask(taskId, { status: "done", completed_at: Date.now() });
+    logEvent({ task_id: taskId, agent_id: agentId, event_type: "completed", payload: {} });
+    const pendingRows = db.query(`SELECT id, blocked_by FROM tasks
+         WHERE status != 'done' AND blocked_by LIKE '%' || ? || '%'`).all(taskId);
+    for (const row of pendingRows) {
+      const blockedBy = JSON.parse(row.blocked_by);
+      if (!blockedBy.includes(taskId))
+        continue;
+      const remaining = blockedBy.filter((id) => id !== taskId);
+      const newStatus = remaining.length === 0 ? "ready" : "blocked";
+      db.run(`UPDATE tasks SET blocked_by = ?, status = ?, updated_at = ? WHERE id = ?`, [JSON.stringify(remaining), newStatus, Date.now(), row.id]);
+      if (newStatus === "ready") {
+        logEvent({
+          task_id: row.id,
+          event_type: "auto_unblocked",
+          payload: { unblocked_by: taskId }
+        });
+      }
     }
-  }
-  if (agentId)
-    db.run(`UPDATE agents SET current_task = NULL WHERE id = ?`, [agentId]);
+    if (agentId)
+      s.releaseAgent.run(agentId);
+    return updated2;
+  });
+  const updated = doComplete();
   return { task: updated };
 }
 function blockTask(taskId, blockerIds, agentId) {
+  const s = stmts2();
+  const db = s.db;
   const task = getTask(taskId);
   if (!task)
     return { task: null, error: "Task not found" };
+  const placeholders = blockerIds.map(() => "?").join(",");
+  const blockerRows = db.query(`SELECT * FROM tasks WHERE id IN (${placeholders})`).all(...blockerIds);
+  const blockerMap = new Map(blockerRows.map((r2) => [r2.id, parseTask(r2)]));
+  const allRows = db.query("SELECT * FROM tasks").all();
+  const allTaskMap = new Map(allRows.map((r2) => [r2.id, parseTask(r2)]));
   for (const bid of blockerIds) {
-    const blocker = getTask(bid);
+    const blocker = blockerMap.get(bid);
     if (!blocker)
       return { task: null, error: `Blocker not found: ${bid}` };
     if (blocker.status === "done") {
       return { task: null, error: `Cannot block on completed task: ${bid}` };
     }
-    if (detectCycle(taskId, bid)) {
+    if (detectCycleFromMap(taskId, bid, allTaskMap)) {
       return { task: null, error: `Circular dependency detected: ${taskId} \u2192 ${bid}` };
     }
   }
   const newBlockedBy = [...new Set([...task.blocked_by, ...blockerIds])];
-  for (const bid of blockerIds) {
-    const blocker = getTask(bid);
-    updateTask(bid, { blocks: [...new Set([...blocker.blocks, taskId])] });
-  }
-  const updated = updateTask(taskId, { blocked_by: newBlockedBy, status: "blocked" });
-  logEvent({
-    task_id: taskId,
-    agent_id: agentId,
-    event_type: "blocked",
-    payload: { blocked_by: blockerIds }
+  const doBlock = db.transaction(() => {
+    for (const bid of blockerIds) {
+      const blocker = blockerMap.get(bid);
+      const newBlocks = JSON.stringify([...new Set([...blocker.blocks, taskId])]);
+      db.run(`UPDATE tasks SET blocks = ?, updated_at = ? WHERE id = ?`, [newBlocks, Date.now(), bid]);
+    }
+    const updated = updateTask(taskId, { blocked_by: newBlockedBy, status: "blocked" });
+    logEvent({
+      task_id: taskId,
+      agent_id: agentId,
+      event_type: "blocked",
+      payload: { blocked_by: blockerIds }
+    });
+    return updated;
   });
-  return { task: updated };
+  return { task: doBlock() };
 }
-function detectCycle(taskId, candidateBlocker, visited = new Set) {
+function detectCycleFromMap(taskId, candidateBlocker, taskMap, visited = new Set) {
   if (candidateBlocker === taskId)
     return true;
   if (visited.has(candidateBlocker))
     return false;
   visited.add(candidateBlocker);
-  const blocker = getTask(candidateBlocker);
+  const blocker = taskMap.get(candidateBlocker);
   if (!blocker)
     return false;
-  return blocker.blocked_by.some((id) => detectCycle(taskId, id, visited));
+  return blocker.blocked_by.some((id) => detectCycleFromMap(taskId, id, taskMap, visited));
 }
 function unblockTask(taskId, fromId, agentId) {
+  const db = stmts2().db;
   const task = getTask(taskId);
   if (!task)
     return { task: null, error: "Task not found" };
@@ -30578,9 +30675,10 @@ function unblockTask(taskId, fromId, agentId) {
     return { task: null, error: `${taskId} is not blocked by ${fromId}` };
   }
   const remaining = task.blocked_by.filter((id) => id !== fromId);
-  const blocker = getTask(fromId);
-  if (blocker) {
-    updateTask(fromId, { blocks: blocker.blocks.filter((id) => id !== taskId) });
+  const blockerRow = db.query("SELECT blocks FROM tasks WHERE id = ?").get(fromId);
+  if (blockerRow) {
+    const blocks = JSON.parse(blockerRow.blocks).filter((id) => id !== taskId);
+    db.run(`UPDATE tasks SET blocks = ?, updated_at = ? WHERE id = ?`, [JSON.stringify(blocks), Date.now(), fromId]);
   }
   const newStatus = remaining.length === 0 ? "ready" : "blocked";
   const updated = updateTask(taskId, { blocked_by: remaining, status: newStatus });
@@ -30605,18 +30703,27 @@ function rejectTask(taskId, reason, agentId) {
   if (task.status !== "review") {
     return { task: null, error: "Task must be in review status to reject" };
   }
-  updateTask(taskId, { status: "in_progress" });
-  addImplementationNote(taskId, `REVIEW REJECTED: ${reason}`, agentId ?? "human");
+  const agent = agentId ?? "human";
+  const entry = {
+    timestamp: Date.now(),
+    agent,
+    note: `REVIEW REJECTED: ${reason}`
+  };
+  const updated = updateTask(taskId, {
+    status: "in_progress",
+    implementation_notes: [...task.implementation_notes, entry]
+  });
+  logEvent({ task_id: taskId, agent_id: agentId, event_type: "note_added", payload: { note: entry.note } });
   logEvent({
     task_id: taskId,
     agent_id: agentId,
     event_type: "rejected",
     payload: { reason }
   });
-  return { task: getTask(taskId) };
+  return { task: updated };
 }
 function unclaimTask(taskId, agentId, reason) {
-  const db = getDb();
+  const s = stmts2();
   const task = getTask(taskId);
   if (!task)
     return { task: null, error: "Task not found" };
@@ -30624,89 +30731,109 @@ function unclaimTask(taskId, agentId, reason) {
     return { task: null, error: `Task is not assigned to ${agentId}` };
   }
   const backStatus = task.blocked_by.length > 0 ? "blocked" : "ready";
-  updateTask(taskId, { assigned_to: null, status: backStatus, started_at: null });
+  let updated;
   if (reason) {
-    addImplementationNote(taskId, `UNCLAIMED by ${agentId}: ${reason}`, agentId);
+    const entry = {
+      timestamp: Date.now(),
+      agent: agentId,
+      note: `UNCLAIMED by ${agentId}: ${reason}`
+    };
+    updated = updateTask(taskId, {
+      assigned_to: null,
+      status: backStatus,
+      started_at: null,
+      implementation_notes: [...task.implementation_notes, entry]
+    });
+    logEvent({ task_id: taskId, agent_id: agentId, event_type: "note_added", payload: { note: entry.note } });
+  } else {
+    updated = updateTask(taskId, { assigned_to: null, status: backStatus, started_at: null });
   }
-  db.run(`UPDATE agents SET current_task = NULL WHERE id = ?`, [agentId]);
+  s.releaseAgent.run(agentId);
   logEvent({
     task_id: taskId,
     agent_id: agentId,
     event_type: "unclaimed",
     payload: { reason: reason ?? "" }
   });
-  return { task: getTask(taskId) };
+  return { task: updated };
 }
 function heartbeat(agentId, taskId) {
-  const db = getDb();
-  db.run(`INSERT INTO agents (id, first_seen, last_seen, current_task)
-     VALUES (?, ?, ?, ?)
-     ON CONFLICT(id) DO UPDATE SET last_seen = excluded.last_seen`, [agentId, Date.now(), Date.now(), taskId ?? null]);
+  const now = Date.now();
+  stmts2().heartbeat.run(agentId, now, now, taskId ?? null);
 }
 function listAgents() {
-  const db = getDb();
+  const db = stmts2().db;
   return db.query("SELECT * FROM agents ORDER BY last_seen DESC").all();
 }
 function getNextTask(agentId) {
-  const tasks = listTasks({ status: "ready" });
+  const db = stmts2().db;
   if (agentId) {
-    const mine = tasks.find((t) => t.assigned_to === agentId);
+    const mine = db.query(`SELECT * FROM tasks WHERE status = 'ready' AND assigned_to = ?
+       ORDER BY ${PRIORITY_ORDER}, created_at ASC LIMIT 1`).get(agentId);
     if (mine)
-      return mine;
+      return parseTask(mine);
   }
-  return tasks.find((t) => t.assigned_to === null) ?? tasks[0] ?? null;
+  const unassigned = db.query(`SELECT * FROM tasks WHERE status = 'ready' AND assigned_to IS NULL
+     ORDER BY ${PRIORITY_ORDER}, created_at ASC LIMIT 1`).get();
+  if (unassigned)
+    return parseTask(unassigned);
+  const any = db.query(`SELECT * FROM tasks WHERE status = 'ready'
+     ORDER BY ${PRIORITY_ORDER}, created_at ASC LIMIT 1`).get();
+  return any ? parseTask(any) : null;
 }
 function getStats() {
-  const db = getDb();
-  const byStatus = db.query("SELECT status, COUNT(*) as count FROM tasks GROUP BY status").all();
-  const byPriority = db.query("SELECT priority, COUNT(*) as count FROM tasks GROUP BY priority").all();
-  const byType = db.query("SELECT type, COUNT(*) as count FROM tasks GROUP BY type").all();
-  const total = db.query("SELECT COUNT(*) as count FROM tasks").get().count;
-  return {
-    by_status: Object.fromEntries(byStatus.map((r2) => [r2.status, r2.count])),
-    by_priority: Object.fromEntries(byPriority.map((r2) => [r2.priority, r2.count])),
-    by_type: Object.fromEntries(byType.map((r2) => [r2.type, r2.count])),
-    total
-  };
+  const db = stmts2().db;
+  const rows = db.query("SELECT status, priority, type, COUNT(*) as count FROM tasks GROUP BY status, priority, type").all();
+  const by_status = {};
+  const by_priority = {};
+  const by_type = {};
+  let total = 0;
+  for (const row of rows) {
+    by_status[row.status] = (by_status[row.status] ?? 0) + row.count;
+    by_priority[row.priority] = (by_priority[row.priority] ?? 0) + row.count;
+    by_type[row.type] = (by_type[row.type] ?? 0) + row.count;
+    total += row.count;
+  }
+  return { by_status, by_priority, by_type, total };
 }
 function deleteTask(taskId, agentId) {
-  const db = getDb();
+  const s = stmts2();
+  const db = s.db;
   const task = getTask(taskId);
   if (!task) {
     return { success: false, error: "Task not found" };
   }
-  const subtasks = listTasks({ parent_id: taskId });
-  if (subtasks.length > 0) {
+  const subtaskCount = s.subtaskCount.get(taskId).count;
+  if (subtaskCount > 0) {
     return {
       success: false,
-      error: `Cannot delete ${taskId} - it has ${subtasks.length} subtask(s). Delete subtasks first.`
+      error: `Cannot delete ${taskId} - it has ${subtaskCount} subtask(s). Delete subtasks first.`
     };
   }
-  logEvent({
-    task_id: taskId,
-    agent_id: agentId,
-    event_type: "deleted",
-    payload: {}
+  const doDelete = db.transaction(() => {
+    logEvent({
+      task_id: taskId,
+      agent_id: agentId,
+      event_type: "deleted",
+      payload: {}
+    });
+    const blocksRows = db.query(`SELECT id, blocks FROM tasks WHERE blocks LIKE '%' || ? || '%' AND id != ?`).all(taskId, taskId);
+    for (const row of blocksRows) {
+      const blocks = JSON.parse(row.blocks).filter((id) => id !== taskId);
+      db.run(`UPDATE tasks SET blocks = ?, updated_at = ? WHERE id = ?`, [JSON.stringify(blocks), Date.now(), row.id]);
+    }
+    const blockedByRows = db.query(`SELECT id, blocked_by FROM tasks WHERE blocked_by LIKE '%' || ? || '%' AND id != ?`).all(taskId, taskId);
+    for (const row of blockedByRows) {
+      const remaining = JSON.parse(row.blocked_by).filter((id) => id !== taskId);
+      const newStatus = remaining.length === 0 ? "ready" : "blocked";
+      db.run(`UPDATE tasks SET blocked_by = ?, status = ?, updated_at = ? WHERE id = ?`, [JSON.stringify(remaining), newStatus, Date.now(), row.id]);
+    }
+    db.run(`UPDATE tasks SET parent_id = NULL, updated_at = ? WHERE parent_id = ?`, [Date.now(), taskId]);
+    db.run("DELETE FROM events WHERE task_id = ?", [taskId]);
+    db.run("UPDATE agents SET current_task = NULL WHERE current_task = ?", [taskId]);
+    db.run("DELETE FROM tasks WHERE id = ?", [taskId]);
   });
-  const allTasks = listTasks();
-  for (const t of allTasks) {
-    if (t.blocks.includes(taskId)) {
-      updateTask(t.id, { blocks: t.blocks.filter((id) => id !== taskId) });
-    }
-    if (t.blocked_by.includes(taskId)) {
-      const remaining = t.blocked_by.filter((id) => id !== taskId);
-      updateTask(t.id, {
-        blocked_by: remaining,
-        status: remaining.length === 0 ? "ready" : "blocked"
-      });
-    }
-    if (t.parent_id === taskId) {
-      updateTask(t.id, { parent_id: null });
-    }
-  }
-  db.run("DELETE FROM events WHERE task_id = ?", [taskId]);
-  db.run("UPDATE agents SET current_task = NULL WHERE current_task = ?", [taskId]);
-  db.run("DELETE FROM tasks WHERE id = ?", [taskId]);
+  doDelete();
   return { success: true };
 }
 
@@ -41096,7 +41223,7 @@ var claimCommand = new Command("claim").description("Claim task(s) to work on th
   requireInitialized();
   const json = isJsonMode(opts.json);
   const agent = requireAgentId(opts.agent, "claim");
-  const allTaskIds = listTasks().map((t) => t.id);
+  const allTaskIds = getAllTaskIds();
   const resolvedIds = resolveTaskIds(taskIds.map((id) => id.toUpperCase()), allTaskIds);
   if (resolvedIds.length === 0) {
     const patternUsed = taskIds.some((id) => isPattern(id));
@@ -41143,7 +41270,7 @@ var startCommand = new Command("start").description("Start working on task(s) (t
   requireInitialized();
   const json = isJsonMode(opts.json);
   const agent = requireAgentId(opts.agent, "start");
-  const allTaskIds = listTasks().map((t) => t.id);
+  const allTaskIds = getAllTaskIds();
   const resolvedIds = resolveTaskIds(taskIds.map((id) => id.toUpperCase()), allTaskIds);
   if (resolvedIds.length === 0) {
     const patternUsed = taskIds.some((id) => isPattern(id));
@@ -41247,7 +41374,7 @@ var doneCommand = new Command("done").description("Mark task(s) as complete (all
   requireInitialized();
   const json = isJsonMode(opts.json);
   const agent = opts.agent ?? process.env.AITASKS_AGENT_ID;
-  const allTaskIds = listTasks().map((t) => t.id);
+  const allTaskIds = getAllTaskIds();
   const resolvedIds = resolveTaskIds(taskIds.map((id) => id.toUpperCase()), allTaskIds);
   if (resolvedIds.length === 0) {
     const patternUsed = taskIds.some((id) => isPattern(id));
@@ -41343,7 +41470,7 @@ var reviewCommand = new Command("review").description("Request human review for
   requireInitialized();
   const json = isJsonMode(opts.json);
   const agent = requireAgentId(opts.agent, "review");
-  const allTaskIds = listTasks().map((t) => t.id);
+  const allTaskIds = getAllTaskIds();
   const resolvedIds = resolveTaskIds(taskIds.map((id) => id.toUpperCase()), allTaskIds);
   if (resolvedIds.length === 0) {
     const patternUsed = taskIds.some((id) => isPattern(id));
@@ -42085,7 +42212,20 @@ var TreeBoardComponent = ({ getTasks }) => {
       const newStatus = statusMap[input];
       if (newStatus && selectedTask) {
         if (newStatus === "done") {
-          const { error } = completeTask(selectedTask.id);
+          let { error, unchecked } = completeTask(selectedTask.id);
+          if (error && unchecked && unchecked.length > 0) {
+            const task = getTask(selectedTask.id);
+            if (task) {
+              for (let i = 0;i < task.acceptance_criteria.length; i++) {
+                const alreadyChecked = task.test_results.some((r2) => r2.index === i);
+                if (!alreadyChecked) {
+                  checkCriterion(selectedTask.id, i, "auto-verified (moved to Done on board)", "human");
+                }
+              }
+              const retry = completeTask(selectedTask.id);
+              error = retry.error;
+            }
+          }
           if (error) {
             setMoveError(error.split(`
 `)[0] ?? error);
@@ -42996,7 +43136,7 @@ var searchCommand = new Command("search").description("Full-text search across t
   }
   const query = queryParts.join(" ").toLowerCase();
   const searchTerms = query.split(/\s+/).filter(Boolean);
-  const allTasks = listTasks(opts.status ? { status: opts.status } : {});
+  const allTasks = searchTasks(searchTerms, opts.status);
   const results = allTasks.filter((task) => matchesSearch(task, searchTerms));
   if (results.length === 0) {
     if (json)
@@ -43253,7 +43393,7 @@ var deleteCommand = new Command("delete").description("Delete task(s) - does not
   requireInitialized();
   const json = isJsonMode(opts.json);
   const agent = opts.agent || process.env.AITASKS_AGENT_ID;
-  const allTaskIds = listTasks().map((t) => t.id);
+  const allTaskIds = getAllTaskIds();
   const resolvedIds = expandPatterns(taskIds.map((id) => id.toUpperCase()), allTaskIds);
   if (resolvedIds.length === 0) {
     exitError("No tasks match the provided IDs/patterns", json);
@@ -43374,4 +43514,4 @@ program2.parseAsync(process.argv).catch((err) => {
   process.exit(1);
 });
 
-//# debugId=517F4D02BD4703B064756E2164756E21
+//# debugId=55B7B23CFF99871064756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aitasks",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "CLI task management tool built for AI agents",
   "type": "module",
   "bin": {