@hasna/conversations 0.2.47 → 0.2.49

package/bin/mcp.js

@@ -7948,9 +7948,9 @@ async function syncTransfer(source, target, options, _direction) {
           const batch = rows.slice(offset, offset + batchSize);
           try {
             if (isAsyncAdapter(target)) {
-              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch);
+              await batchUpsertPg(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
             } else {
-              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch);
+              batchUpsertSqlite(target, table, columns, updateCols, pkColumns, batch, columns.includes(conflictColumn) ? conflictColumn : undefined);
             }
             result.rowsWritten += batch.length;
           } catch (err) {
@@ -7997,7 +7997,7 @@ async function syncTransfer(source, target, options, _direction) {
   }
   return results;
 }
-async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch) {
+async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
@@ -8007,20 +8007,22 @@ async function batchUpsertPg(target, table, columns, updateCols, primaryKeys, ba
   }).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
+  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
   const params = batch.flatMap((row) => columns.map((c) => row[c] ?? null));
   await target.run(sql, ...params);
 }
-function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch) {
+function batchUpsertSqlite(target, table, columns, updateCols, primaryKeys, batch, conflictColumn) {
   if (batch.length === 0)
     return;
   const colList = columns.map((c) => `"${c}"`).join(", ");
   const valuePlaceholders = batch.map(() => `(${columns.map(() => "?").join(", ")})`).join(", ");
   const pkList = primaryKeys.map((c) => `"${c}"`).join(", ");
   const setClause = updateCols.length > 0 ? updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`).join(", ") : `"${primaryKeys[0]}" = EXCLUDED."${primaryKeys[0]}"`;
+  const whereClause = conflictColumn && updateCols.includes(conflictColumn) ? ` WHERE "${table}"."${conflictColumn}" IS NULL OR EXCLUDED."${conflictColumn}" >= "${table}"."${conflictColumn}"` : "";
   const sql = `INSERT INTO "${table}" (${colList}) VALUES ${valuePlaceholders}
-    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}`;
+    ON CONFLICT (${pkList}) DO UPDATE SET ${setClause}${whereClause}`;
   const params = batch.flatMap((row) => columns.map((c) => coerceForSqlite(row[c])));
   target.run(sql, ...params);
 }
@@ -9090,7 +9092,7 @@ async function ensureAllPgDatabases() {
   }
   return results;
 }
-function registerCloudTools(server, serviceName) {
+function registerCloudTools(server, serviceName, opts = {}) {
   server.tool(`${serviceName}_cloud_status`, "Show cloud configuration and connection health", {}, async () => {
     const config2 = getCloudConfig();
     const lines = [
@@ -9123,8 +9125,13 @@ function registerCloudTools(server, serviceName) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(getDbPath(serviceName));
+    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
+    if (opts.migrations?.length) {
+      for (const sql of opts.migrations) {
+        await cloud.run(sql);
+      }
+    }
     const tableList = tablesStr ? tablesStr.split(",").map((t) => t.trim()) : listSqliteTables(local);
     const results = await syncPush(local, cloud, { tables: tableList });
     local.close();
@@ -9146,7 +9153,7 @@ function registerCloudTools(server, serviceName) {
         isError: true
       };
     }
-    const local = new SqliteAdapter(getDbPath(serviceName));
+    const local = new SqliteAdapter(opts.dbPath ?? getDbPath(serviceName));
     const cloud = new PgAdapterAsync(getConnectionString(serviceName));
     let tableList;
     if (tablesStr) {
@@ -18100,6 +18107,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() {
@@ -18474,7 +18575,7 @@ __export(exports_identity, {
   getAutoName: () => getAutoName,
   _resetAutoName: () => _resetAutoName
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync7 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync8 } from "fs";
 import { join as join11, dirname as dirname3 } from "path";
 function isNameTaken(name) {
   try {
@@ -18506,8 +18607,8 @@ function getAutoName() {
   }
   cachedAutoName = name;
   try {
-    mkdirSync7(dirname3(AGENT_ID_FILE), { recursive: true });
-    writeFileSync3(AGENT_ID_FILE, name + `
+    mkdirSync8(dirname3(AGENT_ID_FILE), { recursive: true });
+    writeFileSync5(AGENT_ID_FILE, name + `
 `, "utf-8");
   } catch {}
   return name;
@@ -18533,8 +18634,8 @@ function requireIdentity(explicit) {
 function updateCachedAutoName(newName) {
   cachedAutoName = newName;
   try {
-    mkdirSync7(dirname3(AGENT_ID_FILE), { recursive: true });
-    writeFileSync3(AGENT_ID_FILE, newName + `
+    mkdirSync8(dirname3(AGENT_ID_FILE), { recursive: true });
+    writeFileSync5(AGENT_ID_FILE, newName + `
 `, "utf-8");
   } catch {}
 }
@@ -36290,6 +36391,7 @@ config(en_default2());
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
 var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
@@ -36462,6 +36564,7 @@ var InitializeRequestSchema = RequestSchema.extend({
   method: literal("initialize"),
   params: InitializeRequestParamsSchema
 });
+var isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
 var ServerCapabilitiesSchema = object2({
   experimental: record(string2(), AssertObjectSchema).optional(),
   logging: AssertObjectSchema.optional(),
@@ -40810,12 +40913,12 @@ function setPresenceProject(agent, projectId) {
 // src/lib/messages.ts
 init_db();
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync6, copyFileSync as copyFileSync3, statSync as statSync2, existsSync as existsSync9, realpathSync } from "fs";
+import { mkdirSync as mkdirSync7, copyFileSync as copyFileSync3, statSync as statSync2, existsSync as existsSync10, realpathSync } from "fs";
 import { join as join10, basename, resolve } from "path";
 
 // src/lib/webhooks.ts
 init_db();
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
 import { join as join9 } from "path";
 import dns from "dns";
 import net from "net";
@@ -40920,6 +41023,27 @@ function fireWebhooks(msg) {
     });
   }
 }
+function fireTaskWebhooks(event) {
+  const config2 = loadConfig();
+  if (!config2.webhooks || config2.webhooks.length === 0)
+    return;
+  const taskWebhooks = config2.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(() => {});
+    });
+  }
+}
 
 // src/lib/messages.ts
 function compactMessage(msg) {
@@ -40964,7 +41088,7 @@ function getAttachmentsDir() {
 }
 function validateAttachment(sourcePath, name) {
   const absolute = resolve(sourcePath);
-  if (!existsSync9(absolute)) {
+  if (!existsSync10(absolute)) {
     throw new Error(`Attachment source not found: ${sourcePath}`);
   }
   const real = realpathSync(absolute);
@@ -41046,7 +41170,7 @@ function sendMessage(opts) {
   const message = parseMessage(row);
   if (opts.attachments && opts.attachments.length > 0) {
     const attachmentsDir = join10(getAttachmentsDir(), String(message.id));
-    mkdirSync6(attachmentsDir, { recursive: true });
+    mkdirSync7(attachmentsDir, { recursive: true });
     const attachmentInfos = [];
     for (const att of opts.attachments) {
       const { safeSource, safeName } = validateAttachment(att.source_path, att.name);
@@ -44518,7 +44642,28 @@ function registerAdvancedTools(server, pkgVersion) {
       "remove_agent",
       "rename_agent",
       "search_tools",
-      "describe_tools"
+      "describe_tools",
+      "create_task",
+      "get_task",
+      "list_tasks",
+      "start_task",
+      "complete_task",
+      "cancel_task",
+      "block_task",
+      "unblock_task",
+      "reopen_task",
+      "assign_task",
+      "set_task_priority",
+      "delete_task",
+      "add_comment",
+      "get_comments",
+      "get_subtasks",
+      "get_task_tree",
+      "add_dependency",
+      "remove_dependency",
+      "get_dependencies",
+      "get_dependents",
+      "get_task_activity"
     ];
     const q = query?.toLowerCase();
     const matches = q ? all.filter((n) => n.includes(q)) : all;
@@ -44599,7 +44744,28 @@ function registerAdvancedTools(server, pkgVersion) {
       remove_agent: "Remove agent from presence list. Optional: from?, agent?(defaults to self)",
       rename_agent: "Rename agent in presence list. Required: new_name. Optional: from?",
       search_tools: "Search tool names by keyword. Optional: query?",
-      describe_tools: "Get full descriptions for tools. Required: names(array of tool names)"
+      describe_tools: "Get full descriptions for tools. Required: names(array of tool names)",
+      create_task: "Create a new task. Required: subject, reporter. Optional: description?, assignee?, priority?(low|medium|high|critical), project_id?, space?, parent_id?(subtask), depends_on?(array of task ids), tags?(array), metadata?(JSON), due_at?(ISO date)",
+      get_task: "Get a task by id or uuid. Returns enriched TaskInfo with subtask_count, comment_count, dependency_count, blocker_info. Required: id? or uuid?",
+      list_tasks: "List tasks with filters. Optional: status?(pending|in_progress|completed|cancelled|blocked), assignee?, reporter?, project_id?, space?, parent_id?(null for top-level), priority?, tag?, limit?(default 50), offset?, include_archived?",
+      start_task: "Mark task in_progress. Fails if any dependency not completed. Required: id. Optional: agent?",
+      complete_task: "Mark task completed. Auto-unblocks dependent tasks with all deps met. Required: id. Optional: agent?, evidence?",
+      cancel_task: "Cancel a task with optional reason. Required: id. Optional: agent?, reason?",
+      block_task: "Manually block a task. Required: id. Optional: agent?, reason?",
+      unblock_task: "Unblock a task to pending if all deps completed, stays blocked otherwise. Required: id. Optional: agent?",
+      reopen_task: "Reopen completed/cancelled task back to pending. Re-checks dependencies. Required: id. Optional: agent?",
+      assign_task: "Assign a task to an agent. Required: id, assignee. Optional: agent?",
+      set_task_priority: "Change task priority. Required: id, priority(low|medium|high|critical). Optional: agent?",
+      delete_task: "Delete a task. Fails if subtasks exist. Required: id. Optional: agent?",
+      add_comment: "Add a comment to a task. Required: task_id, content. Optional: agent?",
+      get_comments: "Get all comments on a task ordered by creation time. Required: task_id",
+      get_subtasks: "Get direct children (subtasks) of a parent task. Required: parent_id",
+      get_task_tree: "Get task with full subtask tree (recursive, max depth 5). Required: parent_id. Optional: max_depth?",
+      add_dependency: "Add dependency: task_id depends on depends_on_id. Prevents circular deps. Auto-blocks if dep not completed. Required: task_id, depends_on_id",
+      remove_dependency: "Remove a dependency. Required: task_id, depends_on_id",
+      get_dependencies: "Get tasks this task depends on (must complete first). Required: task_id",
+      get_dependents: "Get tasks that depend on this task (blocked by this). Required: task_id",
+      get_task_activity: "Get activity log: status changes, comments, dep changes. Required: task_id. Optional: limit?(default 50)"
     };
     const result = names.map((n) => `${n}: ${descriptions[n] || "See tool schema"}`).join(`
 `);
@@ -44665,7 +44831,9 @@ function registerCloudSyncTools(server) {
         `Service: conversations`,
         `RDS Host: ${config2.rds.host || "(not configured)"}`
       ];
-      if (config2.rds.host && config2.rds.username) {
+      if (config2.mode === "local") {
+        lines.push("PostgreSQL: skipped in local mode");
+      } else if (config2.rds.host && config2.rds.username) {
         try {
           const pg = new PgAdapterAsync2(getConnectionString2("postgres"));
           await pg.get("SELECT 1 as ok");
@@ -45135,10 +45303,1593 @@ function registerTmuxTools(server) {
     };
   });
 }
+
+// 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 uuid3 = 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(uuid3, 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;
+}
+
+// src/mcp/tools/tasks.ts
+init_identity();
+function registerTaskTools(server) {
+  server.registerTool("create_task", {
+    description: "Create a new task with optional assignee, priority, parent (subtask), dependencies, tags, and metadata.",
+    inputSchema: {
+      subject: exports_external.string(),
+      description: exports_external.string().optional(),
+      reporter: exports_external.string().optional(),
+      assignee: exports_external.string().optional(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      project_id: exports_external.string().optional(),
+      space: exports_external.string().optional(),
+      parent_id: exports_external.coerce.number().optional(),
+      depends_on: exports_external.array(exports_external.coerce.number()).optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+      due_at: exports_external.string().optional()
+    }
+  }, async (args) => {
+    if (!args.reporter) {
+      try {
+        args.reporter = resolveIdentity(undefined);
+      } catch {
+        args.reporter = "unknown";
+      }
+    }
+    const task = createTask({
+      subject: args.subject,
+      description: args.description,
+      reporter: args.reporter,
+      assignee: args.assignee,
+      priority: args.priority,
+      project_id: args.project_id,
+      space: args.space,
+      parent_id: args.parent_id,
+      depends_on: args.depends_on,
+      tags: args.tags,
+      metadata: args.metadata,
+      due_at: args.due_at
+    });
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("get_task", {
+    description: "Get a task by id or uuid. Returns enriched TaskInfo with subtask count, comment count, dependency count, and blocker info.",
+    inputSchema: {
+      id: exports_external.coerce.number().optional(),
+      uuid: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const lookup = args.id ?? args.uuid;
+    if (!lookup)
+      return { content: [{ type: "text", text: "id or uuid required" }], isError: true };
+    const task = getTask(lookup);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${lookup}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("list_tasks", {
+    description: "List tasks with optional filters. Default: 50 tasks, sorted by priority then date. Use 'tags' for AND-matching multiple tags. Use 'metadata' to filter by metadata key/value pairs.",
+    inputSchema: {
+      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled", "blocked"]).optional(),
+      assignee: exports_external.string().optional(),
+      reporter: exports_external.string().optional(),
+      project_id: exports_external.string().optional(),
+      space: exports_external.string().optional(),
+      parent_id: exports_external.coerce.number().nullable().optional(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      tag: exports_external.string().optional(),
+      tags: exports_external.array(exports_external.string()).optional(),
+      metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+      limit: exports_external.coerce.number().optional(),
+      offset: exports_external.coerce.number().optional(),
+      include_archived: exports_external.coerce.boolean().optional()
+    }
+  }, async (args) => {
+    const tasks = listTasks(args);
+    return { content: [{ type: "text", text: JSON.stringify({ tasks, count: tasks.length }) }] };
+  });
+  server.registerTool("start_task", {
+    description: "Mark a task as in_progress. Fails if any dependency is not completed.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      agent: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = startTask(args.id, agent);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("complete_task", {
+    description: "Mark a task as completed. Auto-unblocks any dependent tasks that now have all dependencies completed.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      agent: exports_external.string().optional(),
+      evidence: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = completeTask(args.id, agent, args.evidence ? { evidence: args.evidence } : undefined);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("cancel_task", {
+    description: "Cancel a task with optional reason.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      agent: exports_external.string().optional(),
+      reason: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = cancelTask(args.id, agent, args.reason ? { reason: args.reason } : undefined);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("block_task", {
+    description: "Manually block a task with optional reason.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      agent: exports_external.string().optional(),
+      reason: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = blockTask(args.id, agent, args.reason ? { reason: args.reason } : undefined);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("unblock_task", {
+    description: "Unblock a task. Sets to 'pending' if all dependencies are completed, otherwise stays 'blocked'.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      agent: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = unblockTask(args.id, agent);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("reopen_task", {
+    description: "Reopen a completed or cancelled task back to pending. Re-checks dependencies.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      agent: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = reopenTask(args.id, agent);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("assign_task", {
+    description: "Assign a task to an agent.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      assignee: exports_external.string(),
+      agent: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = assignTask(args.id, args.assignee, agent);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("set_task_priority", {
+    description: "Change a task's priority: low, medium, high, critical.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]),
+      agent: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const task = setTaskPriority(args.id, args.priority, agent);
+    if (!task)
+      return { content: [{ type: "text", text: `Task not found: ${args.id}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(task) }] };
+  });
+  server.registerTool("delete_task", {
+    description: "Delete a task. Fails if subtasks still reference it.",
+    inputSchema: {
+      id: exports_external.coerce.number(),
+      agent: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const deleted = deleteTask(args.id, agent);
+    return { content: [{ type: "text", text: JSON.stringify({ deleted, id: args.id }) }] };
+  });
+  server.registerTool("add_comment", {
+    description: "Add a comment to a task.",
+    inputSchema: {
+      task_id: exports_external.coerce.number(),
+      content: exports_external.string(),
+      agent: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const agent = args.agent ? args.agent : resolveIdentity(undefined);
+    const comment = addComment(args.task_id, agent, args.content);
+    return { content: [{ type: "text", text: JSON.stringify(comment) }] };
+  });
+  server.registerTool("get_comments", {
+    description: "Get all comments on a task, ordered by creation time.",
+    inputSchema: {
+      task_id: exports_external.coerce.number()
+    }
+  }, async (args) => {
+    const comments = getComments(args.task_id);
+    return { content: [{ type: "text", text: JSON.stringify({ comments, count: comments.length }) }] };
+  });
+  server.registerTool("get_subtasks", {
+    description: "Get direct children (subtasks) of a parent task.",
+    inputSchema: {
+      parent_id: exports_external.coerce.number()
+    }
+  }, async (args) => {
+    const subtasks = getSubtasks(args.parent_id);
+    return { content: [{ type: "text", text: JSON.stringify({ subtasks, count: subtasks.length }) }] };
+  });
+  server.registerTool("get_task_tree", {
+    description: "Get a task with its full subtask tree (recursive, max depth 5).",
+    inputSchema: {
+      parent_id: exports_external.coerce.number(),
+      max_depth: exports_external.coerce.number().optional()
+    }
+  }, async (args) => {
+    const tree = getTaskTree(args.parent_id, args.max_depth ?? 5);
+    return { content: [{ type: "text", text: JSON.stringify(tree) }] };
+  });
+  server.registerTool("add_dependency", {
+    description: "Add a dependency: task_id depends on depends_on_id. Prevents circular dependencies. Auto-blocks if dependency not completed.",
+    inputSchema: {
+      task_id: exports_external.coerce.number(),
+      depends_on_id: exports_external.coerce.number()
+    }
+  }, async (args) => {
+    addDependency(args.task_id, args.depends_on_id);
+    return { content: [{ type: "text", text: `Task #${args.task_id} now depends on #${args.depends_on_id}` }] };
+  });
+  server.registerTool("remove_dependency", {
+    description: "Remove a dependency between two tasks.",
+    inputSchema: {
+      task_id: exports_external.coerce.number(),
+      depends_on_id: exports_external.coerce.number()
+    }
+  }, async (args) => {
+    removeDependency(args.task_id, args.depends_on_id);
+    return { content: [{ type: "text", text: `Removed dependency: #${args.task_id} no longer depends on #${args.depends_on_id}` }] };
+  });
+  server.registerTool("get_dependencies", {
+    description: "Get tasks that this task depends on (what must be completed first).",
+    inputSchema: {
+      task_id: exports_external.coerce.number()
+    }
+  }, async (args) => {
+    const deps = getDependencies(args.task_id);
+    return { content: [{ type: "text", text: JSON.stringify({ dependencies: deps, count: deps.length }) }] };
+  });
+  server.registerTool("get_dependents", {
+    description: "Get tasks that depend on this task (what is blocked by this).",
+    inputSchema: {
+      task_id: exports_external.coerce.number()
+    }
+  }, async (args) => {
+    const deps = getDependents(args.task_id);
+    return { content: [{ type: "text", text: JSON.stringify({ dependents: deps, count: deps.length }) }] };
+  });
+  server.registerTool("get_task_activity", {
+    description: "Get activity log for a task: status changes, comments, dependency changes.",
+    inputSchema: {
+      task_id: exports_external.coerce.number(),
+      limit: exports_external.coerce.number().optional()
+    }
+  }, async (args) => {
+    const activity = getTaskActivity(args.task_id, args.limit ?? 50);
+    return { content: [{ type: "text", text: JSON.stringify({ activity, count: activity.length }) }] };
+  });
+  server.registerTool("get_due_tasks", {
+    description: "Get tasks with approaching or past due dates. Returns tasks that are overdue, due today, or due within the specified window (default 24h). Ordered by due_at ascending. Excludes completed and cancelled tasks.",
+    inputSchema: {
+      window_hours: exports_external.coerce.number().optional()
+    }
+  }, async (args) => {
+    const due = getDueTasks({ window_hours: args.window_hours });
+    return { content: [{ type: "text", text: JSON.stringify({ tasks: due, count: due.length }) }] };
+  });
+  server.registerTool("get_task_summary", {
+    description: "Get a structured summary of a task including progress metrics, recent activity, blockers, and dependents. Returns subtask progress, dependency progress, completion percentage, and recent activity log.",
+    inputSchema: {
+      id: exports_external.coerce.number().optional(),
+      uuid: exports_external.string().optional()
+    }
+  }, async (args) => {
+    const lookup = args.id ?? args.uuid;
+    if (!lookup)
+      return { content: [{ type: "text", text: "id or uuid required" }], isError: true };
+    const summary = getTaskSummary(lookup);
+    if (!summary)
+      return { content: [{ type: "text", text: `Task not found: ${lookup}` }], isError: true };
+    return { content: [{ type: "text", text: JSON.stringify(summary) }] };
+  });
+  server.registerTool("search_tasks", {
+    description: "Search tasks using full-text search on subject, description, and tags. Supports phrase queries (quoted) and prefix matching. Optional filters: status, assignee, project_id, space, priority. Use sort='relevance' (default) or 'recent'.",
+    inputSchema: {
+      query: exports_external.string(),
+      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled", "blocked"]).optional(),
+      assignee: exports_external.string().optional(),
+      project_id: exports_external.string().optional(),
+      space: exports_external.string().optional(),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+      limit: exports_external.coerce.number().optional(),
+      sort: exports_external.enum(["relevance", "recent"]).optional(),
+      include_archived: exports_external.coerce.boolean().optional()
+    }
+  }, async (args) => {
+    const results = searchTasks({ query: args.query, ...args });
+    return { content: [{ type: "text", text: JSON.stringify({ tasks: results, count: results.length }) }] };
+  });
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
+class WebStandardStreamableHTTPServerTransport {
+  constructor(options = {}) {
+    this._started = false;
+    this._hasHandledRequest = false;
+    this._streamMapping = new Map;
+    this._requestToStreamMapping = new Map;
+    this._requestResponseMap = new Map;
+    this._initialized = false;
+    this._enableJsonResponse = false;
+    this._standaloneSseStreamId = "_GET_stream";
+    this.sessionIdGenerator = options.sessionIdGenerator;
+    this._enableJsonResponse = options.enableJsonResponse ?? false;
+    this._eventStore = options.eventStore;
+    this._onsessioninitialized = options.onsessioninitialized;
+    this._onsessionclosed = options.onsessionclosed;
+    this._allowedHosts = options.allowedHosts;
+    this._allowedOrigins = options.allowedOrigins;
+    this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
+    this._retryInterval = options.retryInterval;
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("Transport already started");
+    }
+    this._started = true;
+  }
+  createJsonErrorResponse(status, code, message, options) {
+    const error48 = { code, message };
+    if (options?.data !== undefined) {
+      error48.data = options.data;
+    }
+    return new Response(JSON.stringify({
+      jsonrpc: "2.0",
+      error: error48,
+      id: null
+    }), {
+      status,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers
+      }
+    });
+  }
+  validateRequestHeaders(req) {
+    if (!this._enableDnsRebindingProtection) {
+      return;
+    }
+    if (this._allowedHosts && this._allowedHosts.length > 0) {
+      const hostHeader = req.headers.get("host");
+      if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
+        const error48 = `Invalid Host header: ${hostHeader}`;
+        this.onerror?.(new Error(error48));
+        return this.createJsonErrorResponse(403, -32000, error48);
+      }
+    }
+    if (this._allowedOrigins && this._allowedOrigins.length > 0) {
+      const originHeader = req.headers.get("origin");
+      if (originHeader && !this._allowedOrigins.includes(originHeader)) {
+        const error48 = `Invalid Origin header: ${originHeader}`;
+        this.onerror?.(new Error(error48));
+        return this.createJsonErrorResponse(403, -32000, error48);
+      }
+    }
+    return;
+  }
+  async handleRequest(req, options) {
+    if (!this.sessionIdGenerator && this._hasHandledRequest) {
+      throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
+    }
+    this._hasHandledRequest = true;
+    const validationError = this.validateRequestHeaders(req);
+    if (validationError) {
+      return validationError;
+    }
+    switch (req.method) {
+      case "POST":
+        return this.handlePostRequest(req, options);
+      case "GET":
+        return this.handleGetRequest(req);
+      case "DELETE":
+        return this.handleDeleteRequest(req);
+      default:
+        return this.handleUnsupportedRequest();
+    }
+  }
+  async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
+    if (!this._eventStore) {
+      return;
+    }
+    if (protocolVersion < "2025-11-25") {
+      return;
+    }
+    const primingEventId = await this._eventStore.storeEvent(streamId, {});
+    let primingEvent = `id: ${primingEventId}
+data: 
+
+`;
+    if (this._retryInterval !== undefined) {
+      primingEvent = `id: ${primingEventId}
+retry: ${this._retryInterval}
+data: 
+
+`;
+    }
+    controller.enqueue(encoder.encode(primingEvent));
+  }
+  async handleGetRequest(req) {
+    const acceptHeader = req.headers.get("accept");
+    if (!acceptHeader?.includes("text/event-stream")) {
+      return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept text/event-stream");
+    }
+    const sessionError = this.validateSession(req);
+    if (sessionError) {
+      return sessionError;
+    }
+    const protocolError = this.validateProtocolVersion(req);
+    if (protocolError) {
+      return protocolError;
+    }
+    if (this._eventStore) {
+      const lastEventId = req.headers.get("last-event-id");
+      if (lastEventId) {
+        return this.replayEvents(lastEventId);
+      }
+    }
+    if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {
+      return this.createJsonErrorResponse(409, -32000, "Conflict: Only one SSE stream is allowed per session");
+    }
+    const encoder = new TextEncoder;
+    let streamController;
+    const readable = new ReadableStream({
+      start: (controller) => {
+        streamController = controller;
+      },
+      cancel: () => {
+        this._streamMapping.delete(this._standaloneSseStreamId);
+      }
+    });
+    const headers = {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive"
+    };
+    if (this.sessionId !== undefined) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    this._streamMapping.set(this._standaloneSseStreamId, {
+      controller: streamController,
+      encoder,
+      cleanup: () => {
+        this._streamMapping.delete(this._standaloneSseStreamId);
+        try {
+          streamController.close();
+        } catch {}
+      }
+    });
+    return new Response(readable, { headers });
+  }
+  async replayEvents(lastEventId) {
+    if (!this._eventStore) {
+      return this.createJsonErrorResponse(400, -32000, "Event store not configured");
+    }
+    try {
+      let streamId;
+      if (this._eventStore.getStreamIdForEventId) {
+        streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
+        if (!streamId) {
+          return this.createJsonErrorResponse(400, -32000, "Invalid event ID format");
+        }
+        if (this._streamMapping.get(streamId) !== undefined) {
+          return this.createJsonErrorResponse(409, -32000, "Conflict: Stream already has an active connection");
+        }
+      }
+      const headers = {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive"
+      };
+      if (this.sessionId !== undefined) {
+        headers["mcp-session-id"] = this.sessionId;
+      }
+      const encoder = new TextEncoder;
+      let streamController;
+      const readable = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        },
+        cancel: () => {}
+      });
+      const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
+        send: async (eventId, message) => {
+          const success2 = this.writeSSEEvent(streamController, encoder, message, eventId);
+          if (!success2) {
+            this.onerror?.(new Error("Failed replay events"));
+            try {
+              streamController.close();
+            } catch {}
+          }
+        }
+      });
+      this._streamMapping.set(replayedStreamId, {
+        controller: streamController,
+        encoder,
+        cleanup: () => {
+          this._streamMapping.delete(replayedStreamId);
+          try {
+            streamController.close();
+          } catch {}
+        }
+      });
+      return new Response(readable, { headers });
+    } catch (error48) {
+      this.onerror?.(error48);
+      return this.createJsonErrorResponse(500, -32000, "Error replaying events");
+    }
+  }
+  writeSSEEvent(controller, encoder, message, eventId) {
+    try {
+      let eventData = `event: message
+`;
+      if (eventId) {
+        eventData += `id: ${eventId}
+`;
+      }
+      eventData += `data: ${JSON.stringify(message)}
+
+`;
+      controller.enqueue(encoder.encode(eventData));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  handleUnsupportedRequest() {
+    return new Response(JSON.stringify({
+      jsonrpc: "2.0",
+      error: {
+        code: -32000,
+        message: "Method not allowed."
+      },
+      id: null
+    }), {
+      status: 405,
+      headers: {
+        Allow: "GET, POST, DELETE",
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async handlePostRequest(req, options) {
+    try {
+      const acceptHeader = req.headers.get("accept");
+      if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+        return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept both application/json and text/event-stream");
+      }
+      const ct = req.headers.get("content-type");
+      if (!ct || !ct.includes("application/json")) {
+        return this.createJsonErrorResponse(415, -32000, "Unsupported Media Type: Content-Type must be application/json");
+      }
+      const requestInfo = {
+        headers: Object.fromEntries(req.headers.entries())
+      };
+      let rawMessage;
+      if (options?.parsedBody !== undefined) {
+        rawMessage = options.parsedBody;
+      } else {
+        try {
+          rawMessage = await req.json();
+        } catch {
+          return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
+        }
+      }
+      let messages;
+      try {
+        if (Array.isArray(rawMessage)) {
+          messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+        } else {
+          messages = [JSONRPCMessageSchema.parse(rawMessage)];
+        }
+      } catch {
+        return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
+      }
+      const isInitializationRequest = messages.some(isInitializeRequest);
+      if (isInitializationRequest) {
+        if (this._initialized && this.sessionId !== undefined) {
+          return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
+        }
+        if (messages.length > 1) {
+          return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
+        }
+        this.sessionId = this.sessionIdGenerator?.();
+        this._initialized = true;
+        if (this.sessionId && this._onsessioninitialized) {
+          await Promise.resolve(this._onsessioninitialized(this.sessionId));
+        }
+      }
+      if (!isInitializationRequest) {
+        const sessionError = this.validateSession(req);
+        if (sessionError) {
+          return sessionError;
+        }
+        const protocolError = this.validateProtocolVersion(req);
+        if (protocolError) {
+          return protocolError;
+        }
+      }
+      const hasRequests = messages.some(isJSONRPCRequest);
+      if (!hasRequests) {
+        for (const message of messages) {
+          this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
+        }
+        return new Response(null, { status: 202 });
+      }
+      const streamId = crypto.randomUUID();
+      const initRequest = messages.find((m) => isInitializeRequest(m));
+      const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
+      if (this._enableJsonResponse) {
+        return new Promise((resolve2) => {
+          this._streamMapping.set(streamId, {
+            resolveJson: resolve2,
+            cleanup: () => {
+              this._streamMapping.delete(streamId);
+            }
+          });
+          for (const message of messages) {
+            if (isJSONRPCRequest(message)) {
+              this._requestToStreamMapping.set(message.id, streamId);
+            }
+          }
+          for (const message of messages) {
+            this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
+          }
+        });
+      }
+      const encoder = new TextEncoder;
+      let streamController;
+      const readable = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        },
+        cancel: () => {
+          this._streamMapping.delete(streamId);
+        }
+      });
+      const headers = {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      };
+      if (this.sessionId !== undefined) {
+        headers["mcp-session-id"] = this.sessionId;
+      }
+      for (const message of messages) {
+        if (isJSONRPCRequest(message)) {
+          this._streamMapping.set(streamId, {
+            controller: streamController,
+            encoder,
+            cleanup: () => {
+              this._streamMapping.delete(streamId);
+              try {
+                streamController.close();
+              } catch {}
+            }
+          });
+          this._requestToStreamMapping.set(message.id, streamId);
+        }
+      }
+      await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
+      for (const message of messages) {
+        let closeSSEStream;
+        let closeStandaloneSSEStream;
+        if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
+          closeSSEStream = () => {
+            this.closeSSEStream(message.id);
+          };
+          closeStandaloneSSEStream = () => {
+            this.closeStandaloneSSEStream();
+          };
+        }
+        this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
+      }
+      return new Response(readable, { status: 200, headers });
+    } catch (error48) {
+      this.onerror?.(error48);
+      return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error48) });
+    }
+  }
+  async handleDeleteRequest(req) {
+    const sessionError = this.validateSession(req);
+    if (sessionError) {
+      return sessionError;
+    }
+    const protocolError = this.validateProtocolVersion(req);
+    if (protocolError) {
+      return protocolError;
+    }
+    await Promise.resolve(this._onsessionclosed?.(this.sessionId));
+    await this.close();
+    return new Response(null, { status: 200 });
+  }
+  validateSession(req) {
+    if (this.sessionIdGenerator === undefined) {
+      return;
+    }
+    if (!this._initialized) {
+      return this.createJsonErrorResponse(400, -32000, "Bad Request: Server not initialized");
+    }
+    const sessionId = req.headers.get("mcp-session-id");
+    if (!sessionId) {
+      return this.createJsonErrorResponse(400, -32000, "Bad Request: Mcp-Session-Id header is required");
+    }
+    if (sessionId !== this.sessionId) {
+      return this.createJsonErrorResponse(404, -32001, "Session not found");
+    }
+    return;
+  }
+  validateProtocolVersion(req) {
+    const protocolVersion = req.headers.get("mcp-protocol-version");
+    if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+      return this.createJsonErrorResponse(400, -32000, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
+    }
+    return;
+  }
+  async close() {
+    this._streamMapping.forEach(({ cleanup }) => {
+      cleanup();
+    });
+    this._streamMapping.clear();
+    this._requestResponseMap.clear();
+    this.onclose?.();
+  }
+  closeSSEStream(requestId) {
+    const streamId = this._requestToStreamMapping.get(requestId);
+    if (!streamId)
+      return;
+    const stream = this._streamMapping.get(streamId);
+    if (stream) {
+      stream.cleanup();
+    }
+  }
+  closeStandaloneSSEStream() {
+    const stream = this._streamMapping.get(this._standaloneSseStreamId);
+    if (stream) {
+      stream.cleanup();
+    }
+  }
+  async send(message, options) {
+    let requestId = options?.relatedRequestId;
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      requestId = message.id;
+    }
+    if (requestId === undefined) {
+      if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+        throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+      }
+      let eventId;
+      if (this._eventStore) {
+        eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
+      }
+      const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
+      if (standaloneSse === undefined) {
+        return;
+      }
+      if (standaloneSse.controller && standaloneSse.encoder) {
+        this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
+      }
+      return;
+    }
+    const streamId = this._requestToStreamMapping.get(requestId);
+    if (!streamId) {
+      throw new Error(`No connection established for request ID: ${String(requestId)}`);
+    }
+    const stream = this._streamMapping.get(streamId);
+    if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
+      let eventId;
+      if (this._eventStore) {
+        eventId = await this._eventStore.storeEvent(streamId, message);
+      }
+      this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+    }
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      this._requestResponseMap.set(requestId, message);
+      const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_, sid]) => sid === streamId).map(([id]) => id);
+      const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));
+      if (allResponsesReady) {
+        if (!stream) {
+          throw new Error(`No connection established for request ID: ${String(requestId)}`);
+        }
+        if (this._enableJsonResponse && stream.resolveJson) {
+          const headers = {
+            "Content-Type": "application/json"
+          };
+          if (this.sessionId !== undefined) {
+            headers["mcp-session-id"] = this.sessionId;
+          }
+          const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
+          if (responses.length === 1) {
+            stream.resolveJson(new Response(JSON.stringify(responses[0]), { status: 200, headers }));
+          } else {
+            stream.resolveJson(new Response(JSON.stringify(responses), { status: 200, headers }));
+          }
+        } else {
+          stream.cleanup();
+        }
+        for (const id of relatedIds) {
+          this._requestResponseMap.delete(id);
+          this._requestToStreamMapping.delete(id);
+        }
+      }
+    }
+  }
+}
+
+// src/mcp/http.ts
+var DEFAULT_MCP_HTTP_PORT = 8811;
+var MCP_HTTP_HOST = "127.0.0.1";
+var MCP_SERVICE_NAME = "conversations";
+function isHttpMode(args) {
+  return args.includes("--http") || process.env.MCP_HTTP === "1";
+}
+function resolveMcpHttpPort(args) {
+  const portIdx = args.indexOf("--port");
+  if (portIdx >= 0 && args[portIdx + 1]) {
+    return Number(args[portIdx + 1]);
+  }
+  const envPort = process.env.MCP_HTTP_PORT;
+  if (envPort)
+    return Number(envPort);
+  return DEFAULT_MCP_HTTP_PORT;
+}
+function healthPayload(name = MCP_SERVICE_NAME) {
+  return { status: "ok", name };
+}
+async function handleMcpRequest(req, buildServer) {
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: undefined
+  });
+  const server = buildServer();
+  await server.connect(transport);
+  return transport.handleRequest(req);
+}
+function startMcpHttpServer(options) {
+  const { name, port, buildServer } = options;
+  const server = Bun.serve({
+    hostname: MCP_HTTP_HOST,
+    port,
+    async fetch(req) {
+      const url2 = new URL(req.url);
+      if (url2.pathname === "/health" && req.method === "GET") {
+        return Response.json(healthPayload(name));
+      }
+      if (url2.pathname === "/mcp") {
+        return handleMcpRequest(req, buildServer);
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+  });
+  console.error(`${name}-mcp HTTP listening on http://${MCP_HTTP_HOST}:${port}/mcp`);
+  return server;
+}
 // package.json
 var package_default = {
   name: "@hasna/conversations",
-  version: "0.2.47",
+  version: "0.2.49",
   description: "Real-time CLI messaging for AI agents",
   type: "module",
   bin: {
@@ -45189,7 +46940,7 @@ var package_default = {
     typescript: "^5"
   },
   dependencies: {
-    "@hasna/cloud": "^0.1.24",
+    "@hasna/cloud": "^0.1.30",
     "@modelcontextprotocol/sdk": "^1.26.0",
     chalk: "^5.3.0",
     commander: "^12.1.0",
@@ -45197,6 +46948,7 @@ var package_default = {
     "ink-select-input": "^6.0.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
+    pg: "^8.20.0",
     react: "^18.2.0",
     zod: "^4.3.6"
   },
@@ -45218,10 +46970,6 @@ var package_default = {
 };
 
 // src/mcp/index.ts
-var server = new McpServer({
-  name: "conversations",
-  version: package_default.version
-});
 var agentFocus = new Map;
 function getAgentFocus(agentId) {
   if (agentFocus.has(agentId))
@@ -45235,27 +46983,69 @@ function resolveProjectId(explicitProjectId, agentId) {
   const focused = getAgentFocus(agentId);
   return focused ?? undefined;
 }
-registerMessagingTools(server, resolveProjectId);
-registerSpaceTools(server);
-registerProjectTools(server);
-registerAgentTools(server, agentFocus, getAgentFocus);
-registerAdvancedTools(server, package_default.version);
-registerTmuxTools(server);
-registerChannelBridge(server);
-registerTelegramChannel(server);
+function buildServer(forHttp = false) {
+  const srv = new McpServer({
+    name: "conversations",
+    version: package_default.version
+  });
+  registerMessagingTools(srv, resolveProjectId);
+  registerSpaceTools(srv);
+  registerProjectTools(srv);
+  registerAgentTools(srv, agentFocus, getAgentFocus);
+  registerAdvancedTools(srv, package_default.version);
+  registerTaskTools(srv);
+  registerTmuxTools(srv);
+  registerCloudSyncTools(srv);
+  if (!forHttp) {
+    registerChannelBridge(srv);
+    registerTelegramChannel(srv);
+  }
+  return srv;
+}
+var server = buildServer();
 async function startMcpServer() {
   const transport = new StdioServerTransport;
-  registerCloudSyncTools(server);
   await server.connect(transport);
 }
 var isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("mcp.js") || process.argv[1]?.endsWith("mcp.ts");
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(`conversations-mcp \u2014 MCP server for @hasna/conversations v${package_default.version}
+
+Usage:
+  conversations-mcp              stdio transport (default)
+  conversations-mcp --http         Streamable HTTP on 127.0.0.1:8811
+  conversations-mcp --http --port <n>
+
+Environment:
+  MCP_HTTP=1           Enable HTTP mode
+  MCP_HTTP_PORT=<n>    Override default port (8811)
+`);
+    return;
+  }
+  if (args.includes("--version") || args.includes("-V")) {
+    console.log(package_default.version);
+    return;
+  }
+  if (isHttpMode(args)) {
+    startMcpHttpServer({
+      name: "conversations",
+      port: resolveMcpHttpPort(args),
+      buildServer: () => buildServer(true)
+    });
+    return;
+  }
+  await startMcpServer();
+}
 if (isDirectRun) {
-  startMcpServer().catch((error48) => {
+  main().catch((error48) => {
     console.error("MCP server error:", error48);
     process.exit(1);
   });
 }
 export {
   startMcpServer,
-  server
+  server,
+  buildServer
 };