@hasna/mementos 0.14.17 → 0.14.19

package/dist/index.js

@@ -9765,6 +9765,7 @@ CREATE TABLE IF NOT EXISTS machines (
   name TEXT NOT NULL UNIQUE,
   hostname TEXT NOT NULL,
   platform TEXT NOT NULL DEFAULT 'unknown',
+  is_primary INTEGER NOT NULL DEFAULT 0,
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
@@ -10142,6 +10143,46 @@ ALTER TABLE memories ADD COLUMN sequence_group TEXT DEFAULT NULL;
 ALTER TABLE memories ADD COLUMN sequence_order INTEGER DEFAULT NULL;
 CREATE INDEX IF NOT EXISTS idx_memories_sequence_group ON memories(sequence_group) WHERE sequence_group IS NOT NULL;
 INSERT OR IGNORE INTO _migrations (id) VALUES (32);
+`,
+    `
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,
+  subject TEXT NOT NULL,
+  description TEXT DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
+  priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('critical', 'high', 'medium', 'low')),
+  tags TEXT NOT NULL DEFAULT '[]',
+  assigned_agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+  session_id TEXT,
+  parent_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  progress REAL NOT NULL DEFAULT 0 CHECK(progress >= 0 AND progress <= 1),
+  due_at TEXT,
+  started_at TEXT,
+  completed_at TEXT,
+  failed_at TEXT,
+  error TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(assigned_agent_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_task_id);
+
+CREATE TABLE IF NOT EXISTS task_comments (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+  agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+  body TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id);
+CREATE INDEX IF NOT EXISTS idx_task_comments_agent ON task_comments(agent_id);
+INSERT OR IGNORE INTO _migrations (id) VALUES (34);
 `
   ];
 });
@@ -10225,11 +10266,16 @@ function ensureDir(filePath) {
   }
 }
 function getDatabase(dbPath) {
-  if (_db)
-    return _db;
   const path = dbPath || getDbPath2();
+  if (_db) {
+    if (_dbPath === path)
+      return _db;
+    _db.close();
+    _db = null;
+  }
+  _dbPath = path;
   ensureDir(path);
-  _db = new SqliteAdapter(path, { create: true });
+  _db = new SqliteAdapter(path);
   _db.run("PRAGMA journal_mode = WAL");
   _db.run("PRAGMA busy_timeout = 5000");
   _db.run("PRAGMA foreign_keys = ON");
@@ -10253,13 +10299,17 @@ function runMigrations(db) {
     for (let i = currentLevel;i < MIGRATIONS.length; i++) {
       try {
         db.exec(MIGRATIONS[i]);
-      } catch {}
+      } catch (e) {
+        console.warn(`[mementos] Migration ${i + 1} failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
     }
   } catch {
-    for (const migration of MIGRATIONS) {
+    for (let i = 0;i < MIGRATIONS.length; i++) {
       try {
-        db.exec(migration);
-      } catch {}
+        db.exec(MIGRATIONS[i]);
+      } catch (e) {
+        console.warn(`[mementos] Migration ${i + 1} failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
     }
   }
 }
@@ -10282,6 +10332,9 @@ function shortUuid() {
   return crypto.randomUUID().slice(0, 8);
 }
 function resolvePartialId(db, table, partialId) {
+  if (!ALLOWED_TABLES.has(table)) {
+    throw new Error(`Invalid table name: ${table}`);
+  }
   if (partialId.length >= 36) {
     const row = db.query(`SELECT id FROM ${table} WHERE id = ?`).get(partialId);
     return row?.id ?? null;
@@ -10292,10 +10345,25 @@ function resolvePartialId(db, table, partialId) {
   }
   return null;
 }
-var _db = null;
+var _db = null, _dbPath = null, ALLOWED_TABLES;
 var init_database = __esm(() => {
   init_dist();
   init_migrations();
+  ALLOWED_TABLES = new Set([
+    "memories",
+    "agents",
+    "entities",
+    "projects",
+    "relations",
+    "memory_audit_log",
+    "locks",
+    "sessions",
+    "session_memory_jobs",
+    "synthesis_runs",
+    "synthesis_proposals",
+    "tool_events",
+    "webhook_hooks"
+  ]);
 });
 
 // src/types/index.ts
@@ -10836,7 +10904,7 @@ function createMemory(input, dedupeMode = "merge", db) {
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 1, ?, ?, ?, ?, ?, ?)`, [
     id,
     input.key,
-    input.value,
+    safeValue,
     input.category || "knowledge",
     input.scope || "private",
     input.summary || null,
@@ -10999,6 +11067,22 @@ function listMemories(filter, db) {
       conditions.push("session_id = ?");
       params.push(filter.session_id);
     }
+    if ("machine_id" in filter) {
+      if (filter.machine_id === null) {
+        conditions.push("machine_id IS NULL");
+      } else if (filter.machine_id) {
+        conditions.push("machine_id = ?");
+        params.push(filter.machine_id);
+      }
+    }
+    if ("visible_to_machine_id" in filter) {
+      if (filter.visible_to_machine_id === null) {
+        conditions.push("machine_id IS NULL");
+      } else if (filter.visible_to_machine_id !== undefined) {
+        conditions.push("(machine_id IS NULL OR machine_id = ?)");
+        params.push(filter.visible_to_machine_id);
+      }
+    }
     if (filter.min_importance) {
       conditions.push("importance >= ?");
       params.push(filter.min_importance);
@@ -11605,6 +11689,106 @@ function listProjects(db) {
   const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
   return rows.map(parseProjectRow);
 }
+// src/db/machines.ts
+init_database();
+import { hostname, platform as platform2 } from "os";
+function parseMachine(row) {
+  if (!row)
+    return null;
+  return {
+    ...row,
+    is_primary: Boolean(row.is_primary)
+  };
+}
+function normalizeHostname(host) {
+  return host.replace(/\.(local|lan|home|internal)$/i, "");
+}
+function registerMachine(name, db = getDatabase()) {
+  const rawHost = hostname();
+  const host = normalizeHostname(rawHost);
+  const plat = platform2();
+  const machineName = name?.trim() || host;
+  const existing = parseMachine(db.query("SELECT * FROM machines WHERE hostname = ?").get(host));
+  if (existing) {
+    db.run("UPDATE machines SET last_seen_at = ? WHERE id = ?", [now(), existing.id]);
+    return parseMachine(db.query("SELECT * FROM machines WHERE id = ?").get(existing.id));
+  }
+  let finalName = machineName;
+  let suffix = 2;
+  while (db.query("SELECT id FROM machines WHERE name = ?").get(finalName)) {
+    finalName = `${machineName}-${suffix++}`;
+  }
+  const id = uuid();
+  db.run("INSERT INTO machines (id, name, hostname, platform) VALUES (?, ?, ?, ?)", [id, finalName, host, plat]);
+  return parseMachine(db.query("SELECT * FROM machines WHERE id = ?").get(id));
+}
+function listMachines(db = getDatabase()) {
+  const rows = db.query("SELECT * FROM machines ORDER BY is_primary DESC, last_seen_at DESC, created_at ASC").all();
+  return rows.map((row) => parseMachine(row));
+}
+function getMachine(id, db = getDatabase()) {
+  return parseMachine(db.query("SELECT * FROM machines WHERE id = ? OR name = ?").get(id, id));
+}
+function renameMachine(id, newName, db = getDatabase()) {
+  const m = parseMachine(db.query("SELECT * FROM machines WHERE id = ?").get(id));
+  if (!m)
+    throw new Error(`Machine not found: ${id}`);
+  const clash = db.query("SELECT id FROM machines WHERE name = ? AND id != ?").get(newName, id);
+  if (clash)
+    throw new Error(`Machine name already taken: ${newName}`);
+  db.run("UPDATE machines SET name = ?, last_seen_at = ? WHERE id = ?", [newName, now(), id]);
+  return parseMachine(db.query("SELECT * FROM machines WHERE id = ?").get(id));
+}
+function getPrimaryMachine(db = getDatabase()) {
+  return parseMachine(db.query("SELECT * FROM machines WHERE is_primary = 1 LIMIT 1").get());
+}
+function getPrimaryMachineCandidate(db = getDatabase()) {
+  if (getPrimaryMachine(db))
+    return null;
+  return parseMachine(db.query("SELECT * FROM machines ORDER BY created_at ASC, id ASC LIMIT 1").get());
+}
+function setPrimaryMachine(id, db = getDatabase()) {
+  const machine = getMachine(id, db);
+  if (!machine)
+    throw new Error(`Machine not found: ${id}`);
+  const updatedAt = now();
+  db.run("UPDATE machines SET is_primary = 0, last_seen_at = ? WHERE is_primary = 1 AND id != ?", [updatedAt, machine.id]);
+  db.run("UPDATE machines SET is_primary = 1, last_seen_at = ? WHERE id = ?", [updatedAt, machine.id]);
+  return getMachine(machine.id, db);
+}
+function deleteMachine(id, db = getDatabase()) {
+  const machine = getMachine(id, db);
+  if (!machine)
+    throw new Error(`Machine not found: ${id}`);
+  if (machine.is_primary) {
+    throw new Error(`Primary machine cannot be deleted: ${machine.name}`);
+  }
+  db.run("DELETE FROM machines WHERE id = ?", [machine.id]);
+}
+function getFallbackSyncTargetMachine(db = getDatabase()) {
+  return getPrimaryMachine(db);
+}
+function getPrimaryMachineStartupWarning(db = getDatabase()) {
+  if (getPrimaryMachine(db))
+    return null;
+  const candidate = getPrimaryMachineCandidate(db);
+  if (!candidate) {
+    return "No primary machine configured. Fallback sync target is unset because no machines are registered yet.";
+  }
+  return `No primary machine configured. Fallback sync target is unset. Candidate: ${candidate.name} (${candidate.id.slice(0, 8)} / ${candidate.hostname}). Confirm it with set_primary_machine.`;
+}
+function touchMachine(id, db = getDatabase()) {
+  db.run("UPDATE machines SET last_seen_at = ? WHERE id = ?", [now(), id]);
+}
+function getCurrentMachineId(db = getDatabase()) {
+  const host = normalizeHostname(hostname());
+  const m = db.query("SELECT id FROM machines WHERE hostname = ?").get(host);
+  if (m) {
+    touchMachine(m.id, db);
+    return m.id;
+  }
+  return registerMachine(undefined, db).id;
+}
 // src/lib/search.ts
 init_database();
 
@@ -12138,6 +12322,10 @@ function buildFilterConditions(filter) {
       params.push(tag);
     }
   }
+  if (filter.namespace) {
+    conditions.push("m.namespace = ?");
+    params.push(filter.namespace);
+  }
   return { conditions, params };
 }
 function searchWithFts5(d, query, queryLower, filter, graphBoostedIds) {
@@ -12470,6 +12658,23 @@ function ensureDir2(dir) {
     mkdirSync5(dir, { recursive: true });
   }
 }
+// src/lib/machine-visibility.ts
+function resolveVisibleMachineId(machineId, db) {
+  if (machineId !== undefined) {
+    return machineId;
+  }
+  try {
+    return getCurrentMachineId(db);
+  } catch {
+    return null;
+  }
+}
+function visibleToMachineFilter(machineId, db) {
+  return {
+    visible_to_machine_id: resolveVisibleMachineId(machineId, db)
+  };
+}
+
 // src/db/tool-events.ts
 init_database();
 
@@ -12485,12 +12690,14 @@ class MemoryInjector {
     const minImportance = options.min_importance || this.config.injection.min_importance;
     const categories = options.categories || this.config.injection.categories;
     const db = options.db;
+    const visibleMachineId = resolveVisibleMachineId(options.machine_id, db);
     const allMemories = [];
     const globalMems = listMemories({
       scope: "global",
       category: categories,
       min_importance: minImportance,
       status: "active",
+      ...visibleToMachineFilter(visibleMachineId),
       limit: 100
     }, db);
     allMemories.push(...globalMems);
@@ -12501,6 +12708,7 @@ class MemoryInjector {
         min_importance: minImportance,
         status: "active",
         project_id: options.project_id,
+        ...visibleToMachineFilter(visibleMachineId),
         limit: 100
       }, db);
       allMemories.push(...sharedMems);
@@ -12512,6 +12720,7 @@ class MemoryInjector {
         min_importance: minImportance,
         status: "active",
         agent_id: options.agent_id,
+        ...visibleToMachineFilter(visibleMachineId),
         limit: 100
       }, db);
       allMemories.push(...privateMems);
@@ -12523,6 +12732,7 @@ class MemoryInjector {
         ...options.session_id ? { session_id: options.session_id } : {},
         ...options.agent_id ? { agent_id: options.agent_id } : {},
         ...options.project_id ? { project_id: options.project_id } : {},
+        ...visibleToMachineFilter(visibleMachineId),
         limit: 100
       }, db);
       allMemories.push(...workingMems);
@@ -12630,12 +12840,14 @@ ${sections.join(`
     const minImportance = options.min_importance || this.config.injection.min_importance;
     const categories = options.categories || this.config.injection.categories;
     const db = options.db;
+    const visibleMachineId = resolveVisibleMachineId(options.machine_id, db);
     const allMemories = [];
     const globalMems = listMemories({
       scope: "global",
       category: categories,
       min_importance: minImportance,
       status: "active",
+      ...visibleToMachineFilter(visibleMachineId),
       limit: 100
     }, db);
     allMemories.push(...globalMems);
@@ -12646,6 +12858,7 @@ ${sections.join(`
         min_importance: minImportance,
         status: "active",
         project_id: options.project_id,
+        ...visibleToMachineFilter(visibleMachineId),
         limit: 100
       }, db);
       allMemories.push(...sharedMems);
@@ -12657,6 +12870,7 @@ ${sections.join(`
         min_importance: minImportance,
         status: "active",
         agent_id: options.agent_id,
+        ...visibleToMachineFilter(visibleMachineId),
         limit: 100
       }, db);
       allMemories.push(...privateMems);
@@ -12668,6 +12882,7 @@ ${sections.join(`
         ...options.session_id ? { session_id: options.session_id } : {},
         ...options.agent_id ? { agent_id: options.agent_id } : {},
         ...options.project_id ? { project_id: options.project_id } : {},
+        ...visibleToMachineFilter(visibleMachineId),
         limit: 100
       }, db);
       allMemories.push(...workingMems);
@@ -13966,19 +14181,434 @@ function clearActiveModel() {
   delete config.activeModel;
   writeConfig(config);
 }
+// src/db/tasks.ts
+init_database();
+function parseTask(row) {
+  return {
+    id: row.id,
+    subject: row.subject,
+    description: row.description ?? "",
+    status: row.status,
+    priority: row.priority,
+    tags: JSON.parse(row.tags ?? "[]"),
+    assigned_agent_id: row.assigned_agent_id ?? null,
+    project_id: row.project_id ?? null,
+    session_id: row.session_id ?? null,
+    parent_task_id: row.parent_task_id ?? null,
+    metadata: JSON.parse(row.metadata ?? "{}"),
+    progress: row.progress,
+    due_at: row.due_at ?? null,
+    started_at: row.started_at ?? null,
+    completed_at: row.completed_at ?? null,
+    failed_at: row.failed_at ?? null,
+    error: row.error ?? null,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function createTask(db, input) {
+  const id = uuid();
+  const ts = now();
+  db.run(`INSERT INTO tasks (id, subject, description, status, priority, tags, assigned_agent_id, project_id, session_id, parent_task_id, metadata, due_at, created_at, updated_at)
+     VALUES (?, ?, ?, 'pending', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.subject,
+    input.description ?? "",
+    input.priority ?? "medium",
+    JSON.stringify(input.tags ?? []),
+    input.assigned_agent_id ?? null,
+    input.project_id ?? null,
+    input.session_id ?? null,
+    input.parent_task_id ?? null,
+    JSON.stringify(input.metadata ?? {}),
+    input.due_at ?? null,
+    ts,
+    ts
+  ]);
+  const row = db.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  return parseTask(row);
+}
+function getTask(db, id) {
+  const row = db.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  return row ? parseTask(row) : null;
+}
+function listTasks(db, filter) {
+  let sql = "SELECT * FROM tasks WHERE 1=1";
+  let countSql = "SELECT COUNT(*) as c FROM tasks WHERE 1=1";
+  const params = [];
+  const countParams = [];
+  if (filter?.status) {
+    sql += " AND status = ?";
+    countSql += " AND status = ?";
+    params.push(filter.status);
+    countParams.push(filter.status);
+  }
+  if (filter?.priority) {
+    sql += " AND priority = ?";
+    countSql += " AND priority = ?";
+    params.push(filter.priority);
+    countParams.push(filter.priority);
+  }
+  if (filter?.assigned_agent_id) {
+    sql += " AND assigned_agent_id = ?";
+    countSql += " AND assigned_agent_id = ?";
+    params.push(filter.assigned_agent_id);
+    countParams.push(filter.assigned_agent_id);
+  }
+  if (filter?.project_id) {
+    sql += " AND project_id = ?";
+    countSql += " AND project_id = ?";
+    params.push(filter.project_id);
+    countParams.push(filter.project_id);
+  }
+  if (filter?.session_id) {
+    sql += " AND session_id = ?";
+    countSql += " AND session_id = ?";
+    params.push(filter.session_id);
+    countParams.push(filter.session_id);
+  }
+  if (filter?.parent_task_id !== undefined) {
+    if (filter.parent_task_id === null) {
+      sql += " AND parent_task_id IS NULL";
+      countSql += " AND parent_task_id IS NULL";
+    } else {
+      sql += " AND parent_task_id = ?";
+      countSql += " AND parent_task_id = ?";
+      params.push(filter.parent_task_id);
+      countParams.push(filter.parent_task_id);
+    }
+  }
+  if (filter?.tags?.length) {
+    const placeholders = filter.tags.map(() => "?").join(", ");
+    sql += ` AND EXISTS (SELECT 1 FROM json_each(tags) WHERE value IN (${placeholders}))`;
+    countSql += ` AND EXISTS (SELECT 1 FROM json_each(tags) WHERE value IN (${placeholders}))`;
+    params.push(...filter.tags);
+    countParams.push(...filter.tags);
+  }
+  sql += " ORDER BY CASE priority WHEN 'critical' THEN 1 WHEN 'high' THEN 2 WHEN 'medium' THEN 3 WHEN 'low' THEN 4 END, created_at ASC";
+  if (filter?.limit !== undefined) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  if (filter?.offset !== undefined) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  const rows = db.query(sql).all(...params);
+  const countRow = db.query(countSql).get(...countParams);
+  return { tasks: rows.map(parseTask), count: countRow.c };
+}
+function updateTask(db, id, input) {
+  const existing = getTask(db, id);
+  if (!existing)
+    return null;
+  const updates = [];
+  const params = [];
+  const ts = now();
+  if (input.subject !== undefined) {
+    updates.push("subject = ?");
+    params.push(input.subject);
+  }
+  if (input.description !== undefined) {
+    updates.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    updates.push("status = ?");
+    params.push(input.status);
+    if (input.status === "in_progress" && !existing.started_at) {
+      updates.push("started_at = ?");
+      params.push(ts);
+    }
+    if (input.status === "completed") {
+      updates.push("completed_at = ?");
+      params.push(ts);
+      updates.push("progress = ?");
+      params.push(1);
+    }
+    if (input.status === "failed") {
+      updates.push("failed_at = ?");
+      params.push(ts);
+    }
+  }
+  if (input.priority !== undefined) {
+    updates.push("priority = ?");
+    params.push(input.priority);
+  }
+  if (input.tags !== undefined) {
+    updates.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.assigned_agent_id !== undefined) {
+    updates.push("assigned_agent_id = ?");
+    params.push(input.assigned_agent_id);
+  }
+  if (input.metadata !== undefined) {
+    updates.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.progress !== undefined) {
+    updates.push("progress = ?");
+    params.push(input.progress);
+  }
+  if (input.due_at !== undefined) {
+    updates.push("due_at = ?");
+    params.push(input.due_at);
+  }
+  if (input.error !== undefined) {
+    updates.push("error = ?");
+    params.push(input.error);
+  }
+  if (updates.length === 0)
+    return existing;
+  updates.push("updated_at = ?");
+  params.push(ts);
+  params.push(id);
+  db.run(`UPDATE tasks SET ${updates.join(", ")} WHERE id = ?`, ...params);
+  return getTask(db, id);
+}
+function deleteTask(db, id) {
+  const result = db.run("DELETE FROM tasks WHERE id = ?", id);
+  return result.changes > 0;
+}
+function addTaskComment(db, taskId, body, agentId) {
+  const id = uuid();
+  db.run("INSERT INTO task_comments (id, task_id, agent_id, body) VALUES (?, ?, ?, ?)", [id, taskId, agentId ?? null, body]);
+  const row = db.query("SELECT * FROM task_comments WHERE id = ?").get(id);
+  return parseTaskComment(row);
+}
+function parseTaskComment(row) {
+  return {
+    id: row.id,
+    task_id: row.task_id,
+    agent_id: row.agent_id ?? null,
+    body: row.body,
+    created_at: row.created_at
+  };
+}
+function listTaskComments(db, taskId) {
+  const rows = db.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at ASC").all(taskId);
+  return { comments: rows.map(parseTaskComment), count: rows.length };
+}
+function deleteTaskComment(db, id) {
+  const result = db.run("DELETE FROM task_comments WHERE id = ?", id);
+  return result.changes > 0;
+}
+function getTaskStats(db, filter) {
+  let where = "WHERE 1=1";
+  const params = [];
+  if (filter?.project_id) {
+    where += " AND project_id = ?";
+    params.push(filter.project_id);
+  }
+  if (filter?.agent_id) {
+    where += " AND assigned_agent_id = ?";
+    params.push(filter.agent_id);
+  }
+  const total = db.query(`SELECT COUNT(*) as c FROM tasks ${where}`).get(...params).c;
+  const byStatus = {};
+  const statusRows = db.query(`SELECT status, COUNT(*) as c FROM tasks ${where} GROUP BY status`).all(...params);
+  for (const row of statusRows)
+    byStatus[row.status] = row.c;
+  const byPriority = {};
+  const priorityRows = db.query(`SELECT priority, COUNT(*) as c FROM tasks ${where} GROUP BY priority`).all(...params);
+  for (const row of priorityRows)
+    byPriority[row.priority] = row.c;
+  const overdue = db.query(`SELECT COUNT(*) as c FROM tasks ${where} AND status != 'completed' AND status != 'cancelled' AND due_at IS NOT NULL AND due_at < datetime('now')`).get(...params).c;
+  return {
+    total,
+    by_status: {
+      pending: byStatus["pending"] ?? 0,
+      in_progress: byStatus["in_progress"] ?? 0,
+      completed: byStatus["completed"] ?? 0,
+      failed: byStatus["failed"] ?? 0,
+      cancelled: byStatus["cancelled"] ?? 0
+    },
+    by_priority: {
+      critical: byPriority["critical"] ?? 0,
+      high: byPriority["high"] ?? 0,
+      medium: byPriority["medium"] ?? 0,
+      low: byPriority["low"] ?? 0
+    },
+    overdue
+  };
+}
+// src/lib/task-runner.ts
+init_database();
+var _handlers = new Map;
+var _defaultHandler = null;
+function registerTaskHandler(type, handler) {
+  _handlers.set(type, handler);
+}
+function setDefaultTaskHandler(handler) {
+  _defaultHandler = handler;
+}
+function resolveHandler(task) {
+  for (const tag of task.tags) {
+    const h = _handlers.get(tag);
+    if (h)
+      return h;
+  }
+  const metaType = task.metadata?.["type"];
+  if (metaType) {
+    const h = _handlers.get(metaType);
+    if (h)
+      return h;
+  }
+  return _defaultHandler;
+}
+var _workerStarted = false;
+var _processing = false;
+var _totalProcessed = 0;
+var _pollIntervalMs = 60000;
+function startTaskRunner(intervalMs) {
+  if (_workerStarted)
+    return;
+  _workerStarted = true;
+  if (intervalMs)
+    _pollIntervalMs = intervalMs;
+  console.log(`[task-runner] Started, polling every ${_pollIntervalMs / 1000}s`);
+  _tick();
+  setInterval(() => {
+    _tick();
+  }, _pollIntervalMs);
+}
+async function _tick() {
+  if (_processing)
+    return;
+  let task = null;
+  try {
+    const db = getDatabase();
+    const result = listTasks(db, { status: "pending", limit: 1 });
+    if (result.tasks.length === 0)
+      return;
+    task = result.tasks[0] ?? null;
+  } catch (e) {
+    console.error("[task-runner] Failed to list pending tasks:", e);
+    return;
+  }
+  if (!task)
+    return;
+  _processing = true;
+  try {
+    const db = getDatabase();
+    updateTask(db, task.id, { status: "in_progress" });
+    task = getTask(db, task.id);
+  } catch (e) {
+    console.error("[task-runner] Failed to claim task:", e);
+    _processing = false;
+    return;
+  }
+  const handler = resolveHandler(task);
+  if (!handler) {
+    console.warn(`[task-runner] No handler for task: ${task.subject} (tags: ${JSON.stringify(task.tags)}, meta.type: ${task.metadata?.["type"]})`);
+    try {
+      const db = getDatabase();
+      updateTask(db, task.id, {
+        status: "failed",
+        error: "No handler registered for this task type"
+      });
+    } catch {}
+    _processing = false;
+    _totalProcessed++;
+    return;
+  }
+  const taskId = task.id;
+  let progress = 0;
+  const ctx = {
+    task,
+    updateProgress: (p) => {
+      progress = Math.min(1, Math.max(0, p));
+      try {
+        const db = getDatabase();
+        updateTask(db, taskId, { progress });
+      } catch {}
+    },
+    addComment: (body, agentId) => {
+      try {
+        const db = getDatabase();
+        addTaskComment(db, taskId, body, agentId);
+      } catch {}
+    }
+  };
+  try {
+    await handler(ctx);
+    const db = getDatabase();
+    updateTask(db, taskId, { status: "completed", progress: 1 });
+    console.log(`[task-runner] Completed: ${task.subject}`);
+  } catch (e) {
+    const errorMsg = e instanceof Error ? e.message : String(e);
+    try {
+      const db = getDatabase();
+      updateTask(db, taskId, { status: "failed", error: errorMsg });
+    } catch {}
+    console.error(`[task-runner] Failed: ${task.subject} \u2014 ${errorMsg}`);
+  } finally {
+    _processing = false;
+    _totalProcessed++;
+  }
+}
+function getTaskRunnerStats() {
+  try {
+    const db = getDatabase();
+    const rows = db.query("SELECT status, COUNT(*) as c FROM tasks GROUP BY status").all();
+    const stats = {
+      pending: 0,
+      inProgress: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 0,
+      totalProcessed: _totalProcessed
+    };
+    for (const row of rows) {
+      switch (row.status) {
+        case "pending":
+          stats.pending = row.c;
+          break;
+        case "in_progress":
+          stats.inProgress = row.c;
+          break;
+        case "completed":
+          stats.completed = row.c;
+          break;
+        case "failed":
+          stats.failed = row.c;
+          break;
+        case "cancelled":
+          stats.cancelled = row.c;
+          break;
+      }
+    }
+    return stats;
+  } catch {
+    return {
+      pending: 0,
+      inProgress: 0,
+      completed: 0,
+      failed: 0,
+      cancelled: 0,
+      totalProcessed: _totalProcessed
+    };
+  }
+}
 export {
   withMemoryLock,
   uuid,
+  updateTask,
   updateMemory,
   updateEntity,
   updateAgent,
   unlinkEntityFromMemory,
   unfocus,
   touchMemory,
+  touchMachine,
   touchAgent,
   syncMemories,
+  startTaskRunner,
   shortUuid,
+  setPrimaryMachine,
   setFocus,
+  setDefaultTaskHandler,
   setActiveProfile,
   setActiveModel,
   searchMemories,
@@ -13986,11 +14616,14 @@ export {
   resolveProjectId,
   resolvePartialId,
   resetDatabase,
+  renameMachine,
   releaseResourceLocks,
   releaseMemoryWriteLock,
   releaseLock,
   releaseAllAgentLocks,
+  registerTaskHandler,
   registerProject,
+  registerMachine,
   registerAgent,
   redactSecrets,
   providerRegistry,
@@ -14001,25 +14634,36 @@ export {
   mergeEntities,
   memoryLockId,
   loadConfig,
+  listTasks,
+  listTaskComments,
   listRelations,
   listProjects,
   listProfiles,
   listMemories,
+  listMachines,
   listEntities,
   listAgentsByProject,
   listAgents,
   listAgentLocks,
   linkEntityToMemory,
   incrementRecallCount,
+  getTaskStats,
+  getTaskRunnerStats,
+  getTask,
   getRelation,
   getRelatedEntities,
   getProject,
+  getPrimaryMachineStartupWarning,
+  getPrimaryMachineCandidate,
+  getPrimaryMachine,
   getMemoryVersions,
   getMemoryByKey,
   getMemory,
   getMemoriesForEntity,
   getMemoriesByKey,
+  getMachine,
   getFocus,
+  getFallbackSyncTargetMachine,
   getEntityMemoryLinks,
   getEntityGraph,
   getEntityByName,
@@ -14028,6 +14672,7 @@ export {
   getDedupStats,
   getDbPath2 as getDbPath,
   getDatabase,
+  getCurrentMachineId,
   getAutoMemoryStats,
   getAgent,
   getActiveProfile,
@@ -14037,12 +14682,16 @@ export {
   findPath,
   enforceQuotas,
   deprioritizeStale,
+  deleteTaskComment,
+  deleteTask,
   deleteRelation,
   deleteProfile,
   deleteMemory,
+  deleteMachine,
   deleteEntity,
   defaultSyncAgents,
   dedup,
+  createTask,
   createRelation,
   createMemory,
   createEntity,
@@ -14060,6 +14709,7 @@ export {
   archiveUnused,
   archiveStale,
   agentHoldsLock,
+  addTaskComment,
   acquireMemoryWriteLock,
   acquireLock,
   VersionConflictError,