@hasna/conversations 0.2.47 → 0.2.48

package/dist/index.js

@@ -9929,6 +9929,100 @@ function getDb() {
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     )
   `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      uuid TEXT NOT NULL DEFAULT (lower(hex(randomblob(16)))),
+      subject TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      priority TEXT NOT NULL DEFAULT 'medium',
+      assignee TEXT,
+      reporter TEXT NOT NULL,
+      project_id TEXT,
+      space TEXT,
+      parent_id INTEGER REFERENCES tasks(id),
+      depends_on TEXT,
+      tags TEXT,
+      metadata TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      started_at TEXT,
+      completed_at TEXT,
+      cancelled_at TEXT,
+      due_at TEXT
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_uuid ON tasks(uuid)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(assignee)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_reporter ON tasks(reporter)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_space ON tasks(space)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority)");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS task_comments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      agent TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now'))
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id)");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS task_activity (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      agent TEXT NOT NULL,
+      action TEXT NOT NULL,
+      detail TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now'))
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_task_activity_task ON task_activity(task_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_task_activity_agent ON task_activity(agent)");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS task_dependencies (
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      depends_on_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      PRIMARY KEY (task_id, depends_on_id)
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_task_deps_depends ON task_dependencies(depends_on_id)");
+  const hasTasksFts = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tasks_fts'").get();
+  if (!hasTasksFts) {
+    db.exec(`
+      CREATE VIRTUAL TABLE tasks_fts USING fts5(
+        subject, description, tags
+      )
+    `);
+    db.exec(`
+      INSERT INTO tasks_fts(rowid, subject, description, tags)
+      SELECT id, COALESCE(subject, ''), COALESCE(description, ''),
+             COALESCE(REPLACE(REPLACE(REPLACE(tags, '[', ''), ']', ''), '"', ''), '')
+      FROM tasks
+    `);
+    db.exec(`
+      CREATE TRIGGER IF NOT EXISTS tasks_fts_insert AFTER INSERT ON tasks BEGIN
+        INSERT INTO tasks_fts(rowid, subject, description, tags)
+        VALUES (new.id, COALESCE(new.subject, ''), COALESCE(new.description, ''),
+                COALESCE(REPLACE(REPLACE(REPLACE(new.tags, '[', ''), ']', ''), '"', ''), ''));
+      END
+    `);
+    db.exec(`
+      CREATE TRIGGER IF NOT EXISTS tasks_fts_delete AFTER DELETE ON tasks BEGIN
+        DELETE FROM tasks_fts WHERE rowid = old.id;
+      END
+    `);
+    db.exec(`
+      CREATE TRIGGER IF NOT EXISTS tasks_fts_update AFTER UPDATE ON tasks BEGIN
+        INSERT OR REPLACE INTO tasks_fts(rowid, subject, description, tags)
+        VALUES (new.id, COALESCE(new.subject, ''), COALESCE(new.description, ''),
+                COALESCE(REPLACE(REPLACE(REPLACE(new.tags, '[', ''), ']', ''), '"', ''), ''));
+      END
+    `);
+  }
   return db;
 }
 function closeDb() {
@@ -11756,18 +11850,22 @@ var require_react = __commonJS((exports, module) => {
 // src/lib/messages.ts
 init_db();
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync5, copyFileSync as copyFileSync3, statSync as statSync2, existsSync as existsSync6, realpathSync } from "fs";
+import { mkdirSync as mkdirSync6, copyFileSync as copyFileSync3, statSync as statSync2, existsSync as existsSync7, realpathSync } from "fs";
 import { join as join8, basename, resolve } from "path";
 
 // src/lib/webhooks.ts
 init_db();
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync5 } from "fs";
 import { join as join7 } from "path";
 import dns from "dns";
 import net from "net";
 var cachedConfig = null;
 var configLoadedAt = 0;
 var CONFIG_CACHE_MS = 1e4;
+function _resetConfigCache() {
+  cachedConfig = null;
+  configLoadedAt = 0;
+}
 function getConfigPath2() {
   return process.env.CONVERSATIONS_CONFIG_PATH || join7(getDataDir2(), "config.json");
 }
@@ -11866,6 +11964,87 @@ function fireWebhooks(msg) {
     });
   }
 }
+function fireTaskWebhooks(event) {
+  const config = loadConfig();
+  if (!config.webhooks || config.webhooks.length === 0)
+    return;
+  const taskWebhooks = config.webhooks.filter((w) => w.events.includes("task"));
+  if (taskWebhooks.length === 0)
+    return;
+  for (const webhook of taskWebhooks) {
+    if (webhook.agent && event.agent !== webhook.agent)
+      continue;
+    validateWebhookUrl(webhook.url).then((valid) => {
+      if (!valid)
+        return;
+      fetch(webhook.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(event)
+      }).catch(() => {});
+    });
+  }
+}
+function listWebhooks() {
+  const config = loadConfig();
+  return config.webhooks || [];
+}
+async function addWebhook(url, events, agent) {
+  if (!url || !events || events.length === 0) {
+    return { success: false, error: "url and events are required" };
+  }
+  const validEvents = ["dm", "blocker", "space", "mention", "task"];
+  for (const event of events) {
+    if (!validEvents.includes(event)) {
+      return { success: false, error: `Invalid event "${event}". Valid events: ${validEvents.join(", ")}` };
+    }
+  }
+  try {
+    new URL(url);
+  } catch {
+    return { success: false, error: `Invalid URL: ${url}` };
+  }
+  const webhook = { url, events, ...agent ? { agent } : {} };
+  const configPath = getConfigPath2();
+  const configDir = configPath.substring(0, configPath.lastIndexOf("/"));
+  if (!existsSync6(configDir)) {
+    mkdirSync5(configDir, { recursive: true });
+  }
+  let config = {};
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {}
+  if (!config.webhooks)
+    config.webhooks = [];
+  if (config.webhooks.some((w) => w.url === url && w.agent === agent && JSON.stringify(w.events.sort()) === JSON.stringify(events.sort()))) {
+    return { success: false, error: "Webhook already exists" };
+  }
+  config.webhooks.push(webhook);
+  writeFileSync2(configPath, JSON.stringify(config, null, 2), "utf-8");
+  _resetConfigCache();
+  return { success: true, webhook, index: config.webhooks.length - 1 };
+}
+function removeWebhook(index) {
+  const configPath = getConfigPath2();
+  let config = {};
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    config = JSON.parse(raw);
+  } catch {
+    return { success: false, error: "No config file found" };
+  }
+  if (!config.webhooks || config.webhooks.length === 0) {
+    return { success: false, error: "No webhooks configured" };
+  }
+  if (index < 0 || index >= config.webhooks.length) {
+    return { success: false, error: `Invalid index: ${index}. Valid range: 0-${config.webhooks.length - 1}` };
+  }
+  const removed = config.webhooks.splice(index, 1)[0];
+  writeFileSync2(configPath, JSON.stringify(config, null, 2), "utf-8");
+  _resetConfigCache();
+  return { success: true, removed };
+}
 
 // src/lib/messages.ts
 function compactMessage(msg) {
@@ -11910,7 +12089,7 @@ function getAttachmentsDir() {
 }
 function validateAttachment(sourcePath, name) {
   const absolute = resolve(sourcePath);
-  if (!existsSync6(absolute)) {
+  if (!existsSync7(absolute)) {
     throw new Error(`Attachment source not found: ${sourcePath}`);
   }
   const real = realpathSync(absolute);
@@ -11992,7 +12171,7 @@ function sendMessage(opts) {
   const message = parseMessage(row);
   if (opts.attachments && opts.attachments.length > 0) {
     const attachmentsDir = join8(getAttachmentsDir(), String(message.id));
-    mkdirSync5(attachmentsDir, { recursive: true });
+    mkdirSync6(attachmentsDir, { recursive: true });
     const attachmentInfos = [];
     for (const att of opts.attachments) {
       const { safeSource, safeName } = validateAttachment(att.source_path, att.name);
@@ -12987,7 +13166,7 @@ function useSpaceMessages(spaceName) {
   return messages;
 }
 // src/lib/identity.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync7 } from "fs";
 import { join as join9, dirname as dirname3 } from "path";
 
 // src/lib/names.ts
@@ -13373,8 +13552,8 @@ function getAutoName() {
   }
   cachedAutoName = name;
   try {
-    mkdirSync6(dirname3(AGENT_ID_FILE), { recursive: true });
-    writeFileSync2(AGENT_ID_FILE, name + `
+    mkdirSync7(dirname3(AGENT_ID_FILE), { recursive: true });
+    writeFileSync3(AGENT_ID_FILE, name + `
 `, "utf-8");
   } catch {}
   return name;
@@ -14333,25 +14512,29 @@ var gatherTrainingData = async (options = {}) => {
 };
 // src/lib/model-config.ts
 init_db();
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync7, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync8, existsSync as existsSync8 } from "fs";
 import { join as join10 } from "path";
 var DEFAULT_MODEL = "gpt-4o-mini";
-var CONFIG_DIR3 = getDataDir2();
-var CONFIG_PATH2 = join10(CONFIG_DIR3, "config.json");
+function getConfigPath3() {
+  return process.env.CONVERSATIONS_CONFIG_PATH || join10(getDataDir2(), "config.json");
+}
 function readConfig() {
-  if (!existsSync7(CONFIG_PATH2))
+  const path = getConfigPath3();
+  if (!existsSync8(path))
     return {};
   try {
-    return JSON.parse(readFileSync4(CONFIG_PATH2, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!existsSync7(CONFIG_DIR3)) {
-    mkdirSync7(CONFIG_DIR3, { recursive: true });
+  const path = getConfigPath3();
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  if (!existsSync8(dir)) {
+    mkdirSync8(dir, { recursive: true });
   }
-  writeFileSync3(CONFIG_PATH2, JSON.stringify(config, null, 2), "utf-8");
+  writeFileSync4(path, JSON.stringify(config, null, 2), "utf-8");
 }
 function getActiveModel() {
   const config = readConfig();
@@ -14367,6 +14550,696 @@ function clearActiveModel() {
   delete config.activeModel;
   writeConfig(config);
 }
+// src/lib/tasks.ts
+init_db();
+import { randomUUID as randomUUID3 } from "crypto";
+function parseTask(row) {
+  let dependsOn = null;
+  if (row.depends_on) {
+    try {
+      dependsOn = JSON.parse(row.depends_on);
+    } catch {
+      dependsOn = null;
+    }
+  }
+  let tags = null;
+  if (row.tags) {
+    try {
+      tags = JSON.parse(row.tags);
+    } catch {
+      tags = null;
+    }
+  }
+  let metadata = null;
+  if (row.metadata) {
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = null;
+    }
+  }
+  return {
+    id: row.id,
+    uuid: row.uuid,
+    subject: row.subject,
+    description: row.description || null,
+    status: row.status,
+    priority: row.priority,
+    assignee: row.assignee || null,
+    reporter: row.reporter,
+    project_id: row.project_id || null,
+    space: row.space || null,
+    parent_id: row.parent_id || null,
+    depends_on: dependsOn,
+    tags,
+    metadata,
+    created_at: row.created_at,
+    started_at: row.started_at || null,
+    completed_at: row.completed_at || null,
+    cancelled_at: row.cancelled_at || null,
+    due_at: row.due_at || null
+  };
+}
+function logActivity(taskId, agent, action, detail) {
+  const db2 = getDb();
+  db2.prepare("INSERT INTO task_activity (task_id, agent, action, detail) VALUES (?, ?, ?, ?)").run(taskId, agent, action, detail || null);
+}
+function emitTaskEvent(task, action, agent, oldStatus, detail) {
+  fireTaskWebhooks({
+    task_id: task.id,
+    task_uuid: task.uuid,
+    subject: task.subject,
+    action,
+    old_status: oldStatus,
+    new_status: task.status,
+    agent,
+    detail,
+    priority: task.priority,
+    assignee: task.assignee,
+    project_id: task.project_id,
+    created_at: task.created_at
+  });
+}
+function createTask(opts) {
+  const db2 = getDb();
+  const uuid = randomUUID3().replace(/-/g, "");
+  const priority = opts.priority || "medium";
+  const description = opts.description || null;
+  const assignee = opts.assignee || null;
+  const project_id = opts.project_id || null;
+  const space = opts.space || null;
+  const parent_id = opts.parent_id || null;
+  const tags = opts.tags ? JSON.stringify(opts.tags) : null;
+  const metadata = opts.metadata ? JSON.stringify(opts.metadata) : null;
+  const due_at = opts.due_at || null;
+  const row = db2.prepare(`
+    INSERT INTO tasks (uuid, subject, description, reporter, assignee, priority, project_id, space, parent_id, tags, metadata, due_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    RETURNING *
+  `).get(uuid, opts.subject, description, opts.reporter, assignee, priority, project_id, space, parent_id, tags, metadata, due_at);
+  const task = parseTask(row);
+  if (opts.depends_on && opts.depends_on.length > 0) {
+    const depIds = opts.depends_on;
+    const insertDep = db2.prepare("INSERT INTO task_dependencies (task_id, depends_on_id) VALUES (?, ?)");
+    const depIdsResolved = [];
+    for (const depId of depIds) {
+      const exists = db2.prepare("SELECT id, status FROM tasks WHERE id = ?").get(depId);
+      if (!exists)
+        throw new Error(`Dependency task #${depId} not found`);
+      insertDep.run(task.id, depId);
+      depIdsResolved.push(depId);
+    }
+    db2.prepare("UPDATE tasks SET depends_on = ? WHERE id = ?").run(JSON.stringify(depIdsResolved), task.id);
+    const incompleteDeps = db2.prepare("SELECT depends_on_id FROM task_dependencies WHERE task_id = ? AND depends_on_id IN (SELECT id FROM tasks WHERE status != 'completed')").all(task.id);
+    if (incompleteDeps.length > 0) {
+      db2.prepare("UPDATE tasks SET status = 'blocked' WHERE id = ?").run(task.id);
+    }
+  }
+  logActivity(task.id, opts.reporter, "created");
+  const created = parseTask(db2.prepare("SELECT * FROM tasks WHERE id = ?").get(task.id));
+  fireTaskWebhooks({
+    task_id: created.id,
+    task_uuid: created.uuid,
+    subject: created.subject,
+    action: "created",
+    new_status: created.status,
+    agent: opts.reporter,
+    priority: created.priority,
+    assignee: created.assignee,
+    project_id: created.project_id,
+    created_at: created.created_at
+  });
+  return created;
+}
+function getTask(idOrUuid) {
+  const db2 = getDb();
+  let row = null;
+  if (typeof idOrUuid === "number") {
+    row = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(idOrUuid);
+  } else {
+    row = db2.prepare("SELECT * FROM tasks WHERE uuid = ?").get(idOrUuid);
+  }
+  if (!row)
+    return null;
+  return enrichTask(row);
+}
+function listTasks(opts = {}) {
+  const db2 = getDb();
+  const conditions = [];
+  const params = [];
+  if (opts.status) {
+    conditions.push("t.status = ?");
+    params.push(opts.status);
+  }
+  if (opts.assignee) {
+    conditions.push("t.assignee = ?");
+    params.push(opts.assignee);
+  }
+  if (opts.reporter) {
+    conditions.push("t.reporter = ?");
+    params.push(opts.reporter);
+  }
+  if (opts.project_id) {
+    conditions.push("t.project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.space) {
+    conditions.push("t.space = ?");
+    params.push(opts.space);
+  }
+  if (opts.priority) {
+    conditions.push("t.priority = ?");
+    params.push(opts.priority);
+  }
+  if (opts.tag) {
+    conditions.push("t.tags LIKE ?");
+    params.push(`%"${opts.tag}"%`);
+  }
+  if (opts.tags && opts.tags.length > 0) {
+    for (const tag of opts.tags) {
+      conditions.push("t.tags LIKE ?");
+      params.push(`%"${tag}"%`);
+    }
+  }
+  if (opts.metadata && Object.keys(opts.metadata).length > 0) {
+    for (const [key, value] of Object.entries(opts.metadata)) {
+      if (typeof value === "string") {
+        conditions.push(`t.metadata LIKE ?`);
+        params.push(`%"${key}":"${value}"%`);
+      } else if (typeof value === "number" || typeof value === "boolean") {
+        conditions.push(`t.metadata LIKE ?`);
+        params.push(`%"${key}":${value}%`);
+      } else {
+        conditions.push(`t.metadata LIKE ?`);
+        params.push(`%"${key}"%`);
+      }
+    }
+  }
+  if (opts.parent_id === null) {
+    conditions.push("t.parent_id IS NULL");
+  } else if (typeof opts.parent_id === "number") {
+    conditions.push("t.parent_id = ?");
+    params.push(opts.parent_id);
+  }
+  if (!opts.include_archived) {
+    conditions.push("t.status != 'cancelled'");
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? Math.floor(opts.limit) : 50;
+  const offset = Number.isFinite(opts.offset) && opts.offset >= 0 ? Math.floor(opts.offset) : 0;
+  const rows = db2.prepare(`
+    SELECT t.* FROM tasks t
+    ${where}
+    ORDER BY
+      CASE t.priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+      t.created_at DESC
+    LIMIT ? OFFSET ?
+  `).all(...params, limit, offset);
+  return rows.map(enrichTask);
+}
+function startTask(id, agent) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  const incompleteDeps = db2.prepare(`
+    SELECT td.depends_on_id, t.subject, t.status
+    FROM task_dependencies td
+    JOIN tasks t ON t.id = td.depends_on_id
+    WHERE td.task_id = ? AND t.status != 'completed'
+  `).all(task.id);
+  if (incompleteDeps.length > 0) {
+    throw new Error(`Cannot start: blocked by ${incompleteDeps.length} incomplete task(s): ${incompleteDeps.map((d) => `#${d.depends_on_id} "${d.subject}" (${d.status})`).join(", ")}`);
+  }
+  const now = new Date().toISOString();
+  const oldStatus = task.status;
+  db2.prepare("UPDATE tasks SET status = 'in_progress', started_at = ? WHERE id = ?").run(now, task.id);
+  logActivity(task.id, agent || task.reporter, "started");
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "started", agent || task.reporter, oldStatus);
+  return updated;
+}
+function completeTask(id, agent, opts) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  const now = new Date().toISOString();
+  const oldStatus = task.status;
+  db2.prepare("UPDATE tasks SET status = 'completed', completed_at = ? WHERE id = ?").run(now, task.id);
+  logActivity(task.id, agent || task.reporter, "completed", opts?.evidence);
+  unblockDependents(task.id);
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "completed", agent || task.reporter, oldStatus, opts?.evidence);
+  return updated;
+}
+function cancelTask(id, agent, opts) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  const now = new Date().toISOString();
+  const oldStatus = task.status;
+  db2.prepare("UPDATE tasks SET status = 'cancelled', cancelled_at = ? WHERE id = ?").run(now, task.id);
+  logActivity(task.id, agent || task.reporter, "cancelled", opts?.reason);
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "cancelled", agent || task.reporter, oldStatus, opts?.reason);
+  return updated;
+}
+function blockTask(id, agent, opts) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  const oldStatus = task.status;
+  db2.prepare("UPDATE tasks SET status = 'blocked' WHERE id = ?").run(task.id);
+  logActivity(task.id, agent || task.reporter, "blocked", opts?.reason);
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "blocked", agent || task.reporter, oldStatus, opts?.reason);
+  return updated;
+}
+function unblockTask(id, agent) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  const incompleteDeps = db2.prepare(`
+    SELECT 1 FROM task_dependencies td
+    JOIN tasks t ON t.id = td.depends_on_id
+    WHERE td.task_id = ? AND t.status != 'completed'
+    LIMIT 1
+  `).get(task.id);
+  const oldStatus = task.status;
+  const newStatus = incompleteDeps ? "blocked" : "pending";
+  db2.prepare("UPDATE tasks SET status = ? WHERE id = ?").run(newStatus, task.id);
+  logActivity(task.id, agent || task.reporter, "unblocked");
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "unblocked", agent || task.reporter, oldStatus);
+  return updated;
+}
+function reopenTask(id, agent) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  const oldStatus = task.status;
+  db2.prepare("UPDATE tasks SET status = 'pending', completed_at = NULL, cancelled_at = NULL WHERE id = ?").run(task.id);
+  logActivity(task.id, agent || task.reporter, "reopened");
+  const incompleteDeps = db2.prepare(`
+    SELECT 1 FROM task_dependencies td
+    JOIN tasks t ON t.id = td.depends_on_id
+    WHERE td.task_id = ? AND t.status != 'completed'
+    LIMIT 1
+  `).get(task.id);
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "reopened", agent || task.reporter, oldStatus);
+  return updated;
+}
+function assignTask(id, assignee, agent) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  db2.prepare("UPDATE tasks SET assignee = ? WHERE id = ?").run(assignee, task.id);
+  logActivity(task.id, agent || task.reporter, "assigned", assignee);
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "assigned", agent || task.reporter, task.status);
+  return updated;
+}
+function setTaskPriority(id, priority, agent) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return null;
+  const oldPriority = task.priority;
+  db2.prepare("UPDATE tasks SET priority = ? WHERE id = ?").run(priority, task.id);
+  logActivity(task.id, agent || task.reporter, "priority_changed", `${oldPriority} -> ${priority}`);
+  const updated = getTaskById(task.id);
+  if (updated)
+    emitTaskEvent(updated, "priority_changed", agent || task.reporter, task.status, `${oldPriority} -> ${priority}`);
+  return updated;
+}
+function addComment(taskId, agent, content) {
+  const db2 = getDb();
+  const task = resolveTask(taskId);
+  if (!task)
+    throw new Error(`Task not found: ${taskId}`);
+  const row = db2.prepare("INSERT INTO task_comments (task_id, agent, content) VALUES (?, ?, ?) RETURNING *").get(task.id, agent, content);
+  logActivity(task.id, agent, "comment", content.length > 200 ? content.slice(0, 200) + "\u2026" : content);
+  return {
+    id: row.id,
+    task_id: row.task_id,
+    agent: row.agent,
+    content: row.content,
+    created_at: row.created_at
+  };
+}
+function getComments(taskId) {
+  const db2 = getDb();
+  const task = resolveTask(taskId);
+  if (!task)
+    return [];
+  return db2.prepare("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at ASC, id ASC").all(task.id);
+}
+function getSubtasks(parentId) {
+  const db2 = getDb();
+  const parent = resolveTask(parentId);
+  if (!parent)
+    return [];
+  const rows = db2.prepare("SELECT * FROM tasks WHERE parent_id = ? ORDER BY created_at ASC, id ASC").all(parent.id);
+  return rows.map(enrichTask);
+}
+function getTaskTree(parentId, maxDepth = 5) {
+  const root = getTask(typeof parentId === "number" ? parentId : parentId);
+  if (!root)
+    throw new Error(`Task not found: ${parentId}`);
+  const buildTree = (task, depth) => {
+    if (depth >= maxDepth)
+      return { ...task, children: [] };
+    const children = getSubtasks(task.id);
+    return { ...task, children: children.map((c) => buildTree(c, depth + 1)) };
+  };
+  return buildTree(root, 0);
+}
+function addDependency(taskId, dependsOnId) {
+  const db2 = getDb();
+  const task = resolveTask(taskId);
+  const dep = resolveTask(dependsOnId);
+  if (!task)
+    throw new Error(`Task not found: ${taskId}`);
+  if (!dep)
+    throw new Error(`Dependency task not found: ${dependsOnId}`);
+  if (task.id === dep.id)
+    throw new Error("A task cannot depend on itself");
+  if (isCircularDependency(task.id, dep.id)) {
+    throw new Error(`Circular dependency detected: task #${task.id} -> #${dep.id}`);
+  }
+  db2.prepare("INSERT OR IGNORE INTO task_dependencies (task_id, depends_on_id) VALUES (?, ?)").run(task.id, dep.id);
+  const deps = db2.prepare("SELECT depends_on_id FROM task_dependencies WHERE task_id = ?").all(task.id);
+  db2.prepare("UPDATE tasks SET depends_on = ? WHERE id = ?").run(JSON.stringify(deps.map((d) => d.depends_on_id)), task.id);
+  if (dep.status !== "completed") {
+    db2.prepare("UPDATE tasks SET status = 'blocked' WHERE id = ?").run(task.id);
+  }
+  logActivity(task.id, "", "dependency_added", `depends on #${dep.id}`);
+}
+function removeDependency(taskId, dependsOnId) {
+  const db2 = getDb();
+  const task = resolveTask(taskId);
+  if (!task)
+    throw new Error(`Task not found: ${taskId}`);
+  db2.prepare("DELETE FROM task_dependencies WHERE task_id = ? AND depends_on_id = ?").run(task.id, dependsOnId);
+  const deps = db2.prepare("SELECT depends_on_id FROM task_dependencies WHERE task_id = ?").all(task.id);
+  db2.prepare("UPDATE tasks SET depends_on = ? WHERE id = ?").run(JSON.stringify(deps.map((d) => d.depends_on_id)), task.id);
+  logActivity(task.id, "", "dependency_removed", `no longer depends on #${dependsOnId}`);
+}
+function getDependencies(taskId) {
+  const db2 = getDb();
+  const task = resolveTask(taskId);
+  if (!task)
+    return [];
+  return db2.prepare(`
+    SELECT t.* FROM tasks t
+    INNER JOIN task_dependencies td ON td.depends_on_id = t.id
+    WHERE td.task_id = ?
+    ORDER BY t.created_at ASC
+  `).all(task.id).map(parseTask);
+}
+function getDependents(taskId) {
+  const db2 = getDb();
+  const task = resolveTask(taskId);
+  if (!task)
+    return [];
+  return db2.prepare(`
+    SELECT t.* FROM tasks t
+    INNER JOIN task_dependencies td ON td.task_id = t.id
+    WHERE td.depends_on_id = ?
+    ORDER BY t.created_at ASC
+  `).all(task.id).map(parseTask);
+}
+function getTaskActivity(taskId, limit = 50) {
+  const db2 = getDb();
+  const task = resolveTask(taskId);
+  if (!task)
+    return [];
+  const safeLimit = Math.max(1, Math.min(Math.floor(limit), 1000));
+  return db2.prepare(`SELECT * FROM task_activity WHERE task_id = ? ORDER BY created_at DESC LIMIT ${safeLimit}`).all(task.id);
+}
+function deleteTask(id, agent) {
+  const db2 = getDb();
+  const task = resolveTask(id);
+  if (!task)
+    return false;
+  const subtaskCount = db2.prepare("SELECT COUNT(*) as c FROM tasks WHERE parent_id = ?").get(task.id).c;
+  if (subtaskCount > 0) {
+    throw new Error(`Cannot delete: ${subtaskCount} subtask(s) still reference this task`);
+  }
+  logActivity(task.id, agent || "", "deleted");
+  db2.prepare("DELETE FROM tasks WHERE id = ?").run(task.id);
+  return true;
+}
+function searchTasks(opts) {
+  const db2 = getDb();
+  const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? Math.floor(opts.limit) : 20;
+  const sortByRelevance = opts.sort !== "recent";
+  const query = opts.query.trim();
+  const terms = query.split(/\s+/).filter(Boolean);
+  const ftsAvailable = db2.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='tasks_fts'").get();
+  if (ftsAvailable && terms.length > 0) {
+    try {
+      let ftsQuery;
+      if (query.startsWith('"') && query.endsWith('"')) {
+        ftsQuery = query;
+      } else {
+        ftsQuery = terms.map((w) => `"${w.replace(/"/g, '""')}"`).join(" ");
+      }
+      const ftsRows = db2.prepare(`SELECT rowid, rank, snippet(tasks_fts, 0, '**', '**', '...', 10) as snippet
+         FROM tasks_fts WHERE tasks_fts MATCH ? ORDER BY rank LIMIT ${limit * 3}`).all(ftsQuery);
+      if (ftsRows.length === 0) {} else {
+        const ids = ftsRows.map((r) => r.rowid);
+        const placeholders = ids.map(() => "?").join(",");
+        const rows2 = db2.prepare(`SELECT * FROM tasks WHERE id IN (${placeholders})`).all(...ids);
+        const taskMap = new Map;
+        for (const row of rows2)
+          taskMap.set(row.id, row);
+        const rankMap = new Map(ftsRows.map((r) => [r.rowid, { rank: r.rank, snippet: r.snippet }]));
+        const sorted = sortByRelevance ? [...ftsRows].sort((a, b) => a.rank - b.rank) : [...ftsRows].sort((a, b) => {
+          const aTask = taskMap.get(a.rowid);
+          const bTask = taskMap.get(b.rowid);
+          return (bTask?.created_at || "").localeCompare(aTask?.created_at || "");
+        });
+        const results = [];
+        const maxRank = Math.abs(sorted[0].rank) || 1;
+        for (const fts of sorted) {
+          const row = taskMap.get(fts.rowid);
+          if (!row)
+            continue;
+          const task = enrichTask(row);
+          if (opts.status && task.status !== opts.status)
+            continue;
+          if (opts.assignee && task.assignee !== opts.assignee)
+            continue;
+          if (opts.project_id && task.project_id !== opts.project_id)
+            continue;
+          if (opts.space && task.space !== opts.space)
+            continue;
+          if (opts.priority && task.priority !== opts.priority)
+            continue;
+          if (!opts.include_archived && task.status === "cancelled")
+            continue;
+          results.push({
+            ...task,
+            snippet: fts.snippet || null,
+            relevance_score: Math.round((1 - Math.abs(fts.rank) / maxRank) * 100)
+          });
+          if (results.length >= limit)
+            break;
+        }
+        return results;
+      }
+    } catch {}
+  }
+  if (terms.length === 0)
+    return [];
+  const params = [];
+  const conditions = [];
+  for (const term of terms) {
+    conditions.push("(LOWER(t.subject) LIKE ? OR LOWER(t.description) LIKE ? OR LOWER(t.tags) LIKE ?)");
+    const likeTerm = `%${term}%`;
+    params.push(likeTerm, likeTerm, likeTerm);
+  }
+  if (opts.status) {
+    conditions.push("t.status = ?");
+    params.push(opts.status);
+  }
+  if (opts.assignee) {
+    conditions.push("t.assignee = ?");
+    params.push(opts.assignee);
+  }
+  if (opts.project_id) {
+    conditions.push("t.project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.space) {
+    conditions.push("t.space = ?");
+    params.push(opts.space);
+  }
+  if (opts.priority) {
+    conditions.push("t.priority = ?");
+    params.push(opts.priority);
+  }
+  if (!opts.include_archived) {
+    conditions.push("t.status != 'cancelled'");
+  }
+  const orderClause = sortByRelevance ? "ORDER BY CASE t.priority WHEN 'critical' THEN 1 WHEN 'high' THEN 2 WHEN 'medium' THEN 3 WHEN 'low' THEN 4 END, t.created_at DESC" : "ORDER BY t.created_at DESC";
+  const rows = db2.prepare(`SELECT t.* FROM tasks t WHERE ${conditions.join(" AND ")} ${orderClause} LIMIT ${limit}`).all(...params);
+  return rows.map((row) => {
+    const task = enrichTask(row);
+    const subject = row.subject.toLowerCase();
+    const matchCount = terms.filter((t) => subject.includes(t)).length;
+    return {
+      ...task,
+      snippet: null,
+      relevance_score: Math.round(matchCount / terms.length * 100)
+    };
+  });
+}
+function getDueTasks(opts = {}) {
+  const db2 = getDb();
+  const windowHours = opts.window_hours ?? 24;
+  const now = new Date;
+  const deadline = new Date(now.getTime() + windowHours * 60 * 60 * 1000);
+  const rows = db2.prepare(`
+    SELECT t.* FROM tasks t
+    WHERE t.due_at IS NOT NULL
+      AND t.due_at <= ?
+      AND t.status NOT IN ('completed', 'cancelled')
+    ORDER BY t.due_at ASC
+  `).all(deadline.toISOString());
+  return rows.map((row) => {
+    const task = enrichTask(row);
+    const dueAt = new Date(task.due_at);
+    const hoursUntilDue = (dueAt.getTime() - now.getTime()) / (1000 * 60 * 60);
+    let urgency;
+    if (hoursUntilDue < 0)
+      urgency = "overdue";
+    else if (hoursUntilDue <= 24)
+      urgency = "due_today";
+    else
+      urgency = "due_soon";
+    return { task, due_in_hours: Math.round(hoursUntilDue * 10) / 10, urgency };
+  });
+}
+function getTaskSummary(idOrUuid) {
+  const db2 = getDb();
+  const task = getTask(idOrUuid);
+  if (!task)
+    return null;
+  const subtasks = db2.prepare("SELECT status FROM tasks WHERE parent_id = ?").all(task.id);
+  const totalSubtasks = subtasks.length;
+  const completedSubtasks = subtasks.filter((s) => s.status === "completed").length;
+  const depRows = db2.prepare("SELECT td.depends_on_id, t.status FROM task_dependencies td JOIN tasks t ON t.id = td.depends_on_id WHERE td.task_id = ?").all(task.id);
+  const totalDeps = depRows.length;
+  const completedDeps = depRows.filter((d) => d.status === "completed").length;
+  const commentCount = db2.prepare("SELECT COUNT(*) as c FROM task_comments WHERE task_id = ?").get(task.id).c;
+  const items = totalSubtasks + totalDeps;
+  const completed = completedSubtasks + completedDeps;
+  const completionPct = items > 0 ? Math.round(completed / items * 100) : task.status === "completed" ? 100 : 0;
+  const activity = db2.prepare("SELECT action, agent, detail, created_at FROM task_activity WHERE task_id = ? ORDER BY id DESC LIMIT 10").all(task.id);
+  const blockerInfo = db2.prepare("SELECT td.depends_on_id as task_id, t.subject, t.status FROM task_dependencies td JOIN tasks t ON t.id = td.depends_on_id WHERE td.task_id = ? AND t.status != 'completed'").all(task.id);
+  const dependentRows = db2.prepare("SELECT td.task_id, t.subject, t.status FROM task_dependencies td JOIN tasks t ON t.id = td.task_id WHERE td.depends_on_id = ?").all(task.id);
+  return {
+    task,
+    progress: {
+      total_subtasks: totalSubtasks,
+      completed_subtasks: completedSubtasks,
+      total_dependencies: totalDeps,
+      completed_dependencies: completedDeps,
+      comment_count: commentCount,
+      completion_pct: completionPct
+    },
+    recent_activity: activity,
+    blockers: blockerInfo,
+    dependents: dependentRows
+  };
+}
+function enrichTask(row) {
+  const db2 = getDb();
+  const task = parseTask(row);
+  const subtaskCount = db2.prepare("SELECT COUNT(*) as c FROM tasks WHERE parent_id = ?").get(task.id).c;
+  const commentCount = db2.prepare("SELECT COUNT(*) as c FROM task_comments WHERE task_id = ?").get(task.id).c;
+  const depRows = db2.prepare("SELECT depends_on_id FROM task_dependencies WHERE task_id = ?").all(task.id);
+  const depCount = depRows.length;
+  let blockerInfo = [];
+  if (depRows.length > 0) {
+    blockerInfo = depRows.map((d) => {
+      const dep = db2.prepare("SELECT id, subject, status FROM tasks WHERE id = ?").get(d.depends_on_id);
+      return dep ? { task_id: dep.id, subject: dep.subject, status: dep.status } : null;
+    }).filter(Boolean);
+  }
+  return { ...task, subtask_count: subtaskCount, comment_count: commentCount, dependency_count: depCount, blocker_info: blockerInfo };
+}
+function resolveTask(idOrUuid) {
+  const db2 = getDb();
+  if (typeof idOrUuid === "number") {
+    const row2 = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(idOrUuid);
+    return row2 ? parseTask(row2) : null;
+  }
+  const row = db2.prepare("SELECT * FROM tasks WHERE uuid = ?").get(idOrUuid);
+  return row ? parseTask(row) : null;
+}
+function getTaskById(id) {
+  const db2 = getDb();
+  const row = db2.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+  return row ? parseTask(row) : null;
+}
+function unblockDependents(completedTaskId) {
+  const db2 = getDb();
+  const dependents = db2.prepare(`
+    SELECT td.task_id, t.status FROM task_dependencies td
+    JOIN tasks t ON t.id = td.task_id
+    WHERE td.depends_on_id = ?
+  `).all(completedTaskId);
+  for (const dep of dependents) {
+    if (dep.status === "blocked") {
+      const incompleteCount = db2.prepare(`
+        SELECT COUNT(*) as c FROM task_dependencies td
+        JOIN tasks t ON t.id = td.depends_on_id
+        WHERE td.task_id = ? AND t.status != 'completed'
+      `).get(dep.task_id).c;
+      if (incompleteCount === 0) {
+        db2.prepare("UPDATE tasks SET status = 'pending' WHERE id = ?").run(dep.task_id);
+        logActivity(dep.task_id, "", "auto_unblocked", `dependency #${completedTaskId} completed`);
+        const task = getTaskById(dep.task_id);
+        if (task)
+          emitTaskEvent(task, "auto_unblocked", "system", "blocked", `dependency #${completedTaskId} completed`);
+      }
+    }
+  }
+}
+function isCircularDependency(taskId, dependsOnId) {
+  const db2 = getDb();
+  const visited = new Set;
+  let current = dependsOnId;
+  let depth = 0;
+  while (current !== undefined && depth < 20) {
+    if (current === taskId)
+      return true;
+    if (visited.has(current))
+      break;
+    visited.add(current);
+    const parents = db2.prepare("SELECT depends_on_id FROM task_dependencies WHERE task_id = ?").all(current);
+    current = parents.length > 0 ? parents[0].depends_on_id : undefined;
+    depth++;
+  }
+  return false;
+}
 export {
   useSpaceMessages,
   useMessages,
@@ -14374,18 +15247,25 @@ export {
   updateProject,
   unsubscribeFromSpaceNotifications,
   unpinMessage,
+  unblockTask,
   unarchiveSpace,
   tryBulkAcquireLock,
   subscribeToSpaceNotifications,
+  startTask,
   startPolling,
+  setTaskPriority,
   setActiveModel,
   sendMessage,
+  searchTasks,
   searchMessages,
   resolveIdentity,
   requireIdentity,
+  reopenTask,
   renameAgent,
+  removeWebhook,
   removeReaction,
   removePresence,
+  removeDependency,
   releaseStaleAgentLocks,
   releaseLock,
   registerAgent,
@@ -14398,6 +15278,8 @@ export {
   markRead,
   markAllSpaceNotificationsRead,
   markAllRead,
+  listWebhooks,
+  listTasks,
   listSpaces,
   listSpaceNotificationSubscriptions,
   listSessions,
@@ -14414,6 +15296,11 @@ export {
   getUnreadBlockers,
   getTrendingTopics,
   getThreadReplies,
+  getTaskTree,
+  getTaskSummary,
+  getTaskActivity,
+  getTask,
+  getSubtasks,
   getSubscribedSpaces,
   getSpaceTopics,
   getSpaceMembers,
@@ -14431,28 +15318,42 @@ export {
   getPinnedMessages,
   getMessageById,
   getGraphStats,
+  getDueTasks,
+  getDependents,
+  getDependencies,
   getDbPath2 as getDbPath,
   getDb,
   getConversationSummary,
+  getComments,
   getAgentNetwork,
   getActiveModel,
   gatherTrainingData,
   fireWebhooks,
+  fireTaskWebhooks,
   extractTopics,
   exportMessages,
   editMessage,
+  deleteTask,
   deleteProject,
   deleteMessage,
+  createTask,
   createSpace,
   createProject,
   computeHotness,
+  completeTask,
   closeDb,
   clearActiveModel,
   cleanExpiredLocks,
   checkLock,
+  cancelTask,
   buildMessagePreview,
   buildGraph,
+  blockTask,
+  assignTask,
   archiveSpace,
+  addWebhook,
   addReaction,
+  addDependency,
+  addComment,
   acquireLock
 };