@hasna/mementos 0.14.18 → 0.14.20

package/dist/server/index.js

@@ -9790,6 +9790,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'))
 );
@@ -10169,33 +10170,44 @@ CREATE INDEX IF NOT EXISTS idx_memories_sequence_group ON memories(sequence_grou
 INSERT OR IGNORE INTO _migrations (id) VALUES (32);
 `,
     `
-ALTER TABLE machines ADD COLUMN is_primary INTEGER NOT NULL DEFAULT 0;
-CREATE INDEX IF NOT EXISTS idx_machines_primary ON machines(is_primary);
-CREATE TRIGGER IF NOT EXISTS machines_single_primary_insert
-AFTER INSERT ON machines
-WHEN NEW.is_primary = 1
-BEGIN
-  UPDATE machines
-  SET is_primary = 0,
-      last_seen_at = COALESCE(NEW.last_seen_at, datetime('now'))
-  WHERE id != NEW.id AND is_primary = 1;
-END;
-CREATE TRIGGER IF NOT EXISTS machines_single_primary_update
-AFTER UPDATE OF is_primary ON machines
-WHEN NEW.is_primary = 1
-BEGIN
-  UPDATE machines
-  SET is_primary = 0,
-      last_seen_at = COALESCE(NEW.last_seen_at, datetime('now'))
-  WHERE id != NEW.id AND is_primary = 1;
-END;
-CREATE TRIGGER IF NOT EXISTS machines_prevent_delete_primary
-BEFORE DELETE ON machines
-WHEN OLD.is_primary = 1
-BEGIN
-  SELECT RAISE(ABORT, 'Primary machine cannot be deleted');
-END;
-INSERT OR IGNORE INTO _migrations (id) VALUES (33);
+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);
 `
   ];
 });
@@ -10886,7 +10898,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,
@@ -11793,6 +11805,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) {
@@ -13756,8 +13772,12 @@ function parseMachine(row) {
     is_primary: Boolean(row.is_primary)
   };
 }
+function normalizeHostname(host) {
+  return host.replace(/\.(local|lan|home|internal)$/i, "");
+}
 function registerMachine(name, db = getDatabase()) {
-  const host = hostname();
+  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));
@@ -13795,7 +13815,7 @@ function touchMachine(id, db = getDatabase()) {
   db.run("UPDATE machines SET last_seen_at = ? WHERE id = ?", [now(), id]);
 }
 function getCurrentMachineId(db = getDatabase()) {
-  const host = hostname();
+  const host = normalizeHostname(hostname());
   const m = db.query("SELECT id FROM machines WHERE hostname = ?").get(host);
   if (m) {
     touchMachine(m.id, db);
@@ -14841,6 +14861,374 @@ async function _processNext() {
   }
 }
 
+// src/lib/task-runner.ts
+init_database();
+
+// 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);
+  if (!row) {
+    throw new Error(`Failed to load task after create: ${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
+var _handlers = new Map;
+var _defaultHandler = null;
+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 _workerStarted2 = false;
+var _processing = false;
+var _totalProcessed = 0;
+var _pollIntervalMs = 60000;
+function startTaskRunner(intervalMs) {
+  if (_workerStarted2)
+    return;
+  _workerStarted2 = 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++;
+  }
+}
+
 // src/server/router.ts
 var routes = [];
 var nextRouteOrder = 0;
@@ -14917,8 +15305,13 @@ function errorResponse(message, status, details) {
     body["details"] = details;
   return json(body, status);
 }
+var MAX_BODY_BYTES = 1 * 1024 * 1024;
 async function readJson(req) {
   try {
+    const contentLength = req.headers.get("content-length");
+    if (contentLength && Number(contentLength) > MAX_BODY_BYTES) {
+      throw Object.assign(new Error("Payload too large"), { status: 413 });
+    }
     return await req.json();
   } catch {
     return null;
@@ -15057,6 +15450,8 @@ addRoute("GET", "/api/memories", (_req, url) => {
     filter.project_id = q["project_id"];
   if (q["session_id"])
     filter.session_id = q["session_id"];
+  if (q["namespace"])
+    filter.namespace = q["namespace"];
   if (q["status"])
     filter.status = q["status"];
   if (q["limit"])
@@ -15316,6 +15711,10 @@ addRoute("POST", "/api/memories/search", async (req) => {
     filter.category = body["category"];
   if (body["tags"])
     filter.tags = body["tags"];
+  if (body["session_id"])
+    filter.session_id = body["session_id"];
+  if (body["namespace"])
+    filter.namespace = body["namespace"];
   if (body["limit"])
     filter.limit = body["limit"];
   const results = searchMemories(body["query"], filter);
@@ -15337,6 +15736,10 @@ addRoute("POST", "/api/memories/search/hybrid", async (req) => {
     filter.agent_id = body["agent_id"];
   if (body["project_id"])
     filter.project_id = body["project_id"];
+  if (body["session_id"])
+    filter.session_id = body["session_id"];
+  if (body["namespace"])
+    filter.namespace = body["namespace"];
   const results = await hybridSearch(body["query"], {
     filter,
     semantic_threshold: body["semantic_threshold"] ?? undefined,
@@ -15360,6 +15763,10 @@ addRoute("POST", "/api/memories/search/bm25", async (req) => {
     filter.agent_id = body["agent_id"];
   if (body["project_id"])
     filter.project_id = body["project_id"];
+  if (body["session_id"])
+    filter.session_id = body["session_id"];
+  if (body["namespace"])
+    filter.namespace = body["namespace"];
   if (body["limit"])
     filter.limit = body["limit"];
   const results = searchWithBm25(body["query"], filter);
@@ -16248,6 +16655,81 @@ addRoute("GET", "/api/graph/:entityId", (_req, url, params) => {
   }
 });
 
+// src/server/routes/tasks.ts
+init_database();
+addRoute("POST", "/api/tasks", async (req, _url) => {
+  const body = await readJson(req);
+  if (!body)
+    return errorResponse("Invalid JSON body", 400);
+  if (!body.subject)
+    return errorResponse("subject is required", 400);
+  const task = createTask(getDatabase(), body);
+  return json(task, 201);
+});
+addRoute("GET", "/api/tasks", async (_req, url) => {
+  const q = getSearchParams(url);
+  const filter = {};
+  for (const key of ["status", "priority", "assigned_agent_id", "project_id", "session_id", "parent_task_id"]) {
+    if (q[key])
+      filter[key] = q[key];
+  }
+  if (q["tags"])
+    filter.tags = q["tags"].split(",");
+  if (q["limit"])
+    filter.limit = parseInt(q["limit"]);
+  if (q["offset"])
+    filter.offset = parseInt(q["offset"]);
+  return json(listTasks(getDatabase(), filter));
+});
+addRoute("GET", "/api/tasks/stats", async (_req, url) => {
+  const q = getSearchParams(url);
+  const filter = {};
+  if (q["project_id"])
+    filter.project_id = q["project_id"];
+  if (q["agent_id"])
+    filter.agent_id = q["agent_id"];
+  return json(getTaskStats(getDatabase(), filter));
+});
+addRoute("GET", "/api/tasks/:id", async (_req, _url, params) => {
+  const task = getTask(getDatabase(), params.id);
+  if (!task)
+    return errorResponse("Task not found", 404);
+  return json(task);
+});
+addRoute("PATCH", "/api/tasks/:id", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body)
+    return errorResponse("Invalid JSON body", 400);
+  const task = updateTask(getDatabase(), params.id, body);
+  if (!task)
+    return errorResponse("Task not found", 404);
+  return json(task);
+});
+addRoute("DELETE", "/api/tasks/:id", async (_req, _url, params) => {
+  const deleted = deleteTask(getDatabase(), params.id);
+  if (!deleted)
+    return errorResponse("Task not found", 404);
+  return json({ deleted: true });
+});
+addRoute("GET", "/api/tasks/:id/comments", async (_req, _url, params) => {
+  return json(listTaskComments(getDatabase(), params.id));
+});
+addRoute("POST", "/api/tasks/:id/comments", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body)
+    return errorResponse("Invalid JSON body", 400);
+  if (!body.body)
+    return errorResponse("body is required", 400);
+  const comment = addTaskComment(getDatabase(), params.id, body.body, body.agent_id);
+  return json(comment, 201);
+});
+addRoute("DELETE", "/api/tasks/:id/comments/:commentId", async (_req, _url, params) => {
+  const deleted = deleteTaskComment(getDatabase(), params.commentId);
+  if (!deleted)
+    return errorResponse("Comment not found", 404);
+  return json({ deleted: true });
+});
+
 // src/server/routes/system-auto-memory.ts
 init_auto_memory();
 init_registry();
@@ -16295,14 +16777,18 @@ function registerSystemAutoMemoryRoutes() {
     const provider = providerName ? providerRegistry.getProvider(providerName) : providerRegistry.getAvailable();
     if (!provider)
       return errorResponse("No LLM provider configured. Set an API key (ANTHROPIC_API_KEY, OPENAI_API_KEY, CEREBRAS_API_KEY, or XAI_API_KEY).", 503);
-    const memories = await provider.extractMemories(turn, { agentId: agent_id, projectId: project_id });
-    return json({
-      provider: provider.name,
-      model: provider.config.model,
-      extracted: memories,
-      count: memories.length,
-      note: "DRY RUN \u2014 nothing was saved"
-    });
+    try {
+      const memories = await provider.extractMemories(turn, { agentId: agent_id, projectId: project_id });
+      return json({
+        provider: provider.name,
+        model: provider.config.model,
+        extracted: memories,
+        count: memories.length,
+        note: "DRY RUN \u2014 nothing was saved"
+      });
+    } catch (e) {
+      return json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
   });
 }
 
@@ -17284,14 +17770,18 @@ init_profile_synthesizer();
 function registerSystemSynthesisRoutes() {
   addRoute("POST", "/api/synthesis/run", async (req) => {
     const body = await readJson(req) ?? {};
-    const result = await runSynthesis({
-      projectId: body.project_id,
-      agentId: body.agent_id,
-      dryRun: body.dry_run,
-      maxProposals: body.max_proposals,
-      provider: body.provider
-    });
-    return json(result, result.dryRun ? 200 : 201);
+    try {
+      const result = await runSynthesis({
+        projectId: body.project_id,
+        agentId: body.agent_id,
+        dryRun: body.dry_run,
+        maxProposals: body.max_proposals,
+        provider: body.provider
+      });
+      return json(result, result.dryRun ? 200 : 201);
+    } catch (e) {
+      return json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
   });
   addRoute("GET", "/api/synthesis/runs", (_req, url) => {
     const projectId = url.searchParams.get("project_id") ?? undefined;
@@ -17305,20 +17795,28 @@ function registerSystemSynthesisRoutes() {
     return json(getSynthesisStatus(runId, projectId));
   });
   addRoute("POST", "/api/synthesis/rollback/:run_id", async (_req, _url, params) => {
-    const result = await rollbackSynthesis(params["run_id"]);
-    return json(result);
+    try {
+      const result = await rollbackSynthesis(params["run_id"]);
+      return json(result);
+    } catch (e) {
+      return json({ error: e instanceof Error ? e.message : String(e) }, 500);
+    }
   });
   addRoute("GET", "/api/profile/synthesize", async (_req, url) => {
     const q = getSearchParams(url);
-    const result = await synthesizeProfile({
-      project_id: q["project_id"] || undefined,
-      agent_id: q["agent_id"] || undefined,
-      force_refresh: q["force_refresh"] === "true"
-    });
-    if (!result) {
-      return json({ profile: null, message: "No preference/fact memories found to synthesize" });
+    try {
+      const result = await synthesizeProfile({
+        project_id: q["project_id"] || undefined,
+        agent_id: q["agent_id"] || undefined,
+        force_refresh: q["force_refresh"] === "true"
+      });
+      if (!result) {
+        return json({ profile: null, message: "No preference/fact memories found to synthesize" });
+      }
+      return json(result);
+    } catch (e) {
+      return json({ error: e instanceof Error ? e.message : String(e) }, 500);
     }
-    return json(result);
   });
 }
 
@@ -17582,126 +18080,116 @@ function initServer() {
   warnIfPrimaryMachineUnset();
   loadWebhooksFromDb();
   startSessionQueueWorker();
+  startTaskRunner();
 }
-function startServer(port, attempt = 0) {
-  const maxRetries = 100;
+function startServer(port) {
   initServer();
   const hostname2 = process.env["MEMENTOS_HOST"] ?? "127.0.0.1";
-  try {
-    Bun.serve({
-      port,
-      hostname: hostname2,
-      async fetch(req) {
-        const url = new URL(req.url);
-        const { pathname } = url;
-        if (req.method === "OPTIONS") {
-          const origin = req.headers.get("origin");
-          const allowedOrigin = process.env["MEMENTOS_CORS_ORIGIN"] ?? "http://localhost:19428";
-          if (origin && origin !== allowedOrigin) {
-            return new Response(null, { status: 403 });
-          }
-          return new Response(null, { status: 204, headers: getCorsHeaders(req) });
-        }
-        if (pathname === "/api/health" || pathname === "/health") {
-          const profile = getActiveProfile();
-          const { createRequire: createRequire2 } = await import("module");
-          const req2 = createRequire2(import.meta.url);
-          const pkg = req2("../../package.json");
-          const db = getDatabase();
-          const total = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'active'").get().c;
-          const expired = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'expired' OR (expires_at IS NOT NULL AND expires_at < datetime('now'))").get().c;
-          const pinned = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'active' AND pinned = 1").get().c;
-          const agents = db.query("SELECT COUNT(*) as c FROM agents").get().c;
-          const projects = db.query("SELECT COUNT(*) as c FROM projects").get().c;
-          const status = expired > 50 ? "warn" : "ok";
-          return json({ status, version: pkg.version, profile: profile ?? "default", db_path: getDbPath(), hostname: hostname2, memories: { total, expired, pinned }, agents, projects });
-        }
-        if (pathname.startsWith("/api/") && pathname !== "/api/health") {
-          const authError = authenticateRequest(req);
-          if (authError)
-            return authError;
-        }
-        if (pathname === "/api/profile" && req.method === "GET") {
-          const profile = getActiveProfile();
-          return json({ active: profile ?? null, profiles: listProfiles(), db_path: getDbPath() });
-        }
-        if (pathname === "/api/memories/stream" && req.method === "GET") {
-          const stream = new ReadableStream({
-            start(controller) {
-              const encoder = new TextEncoder;
-              let lastSeen = new Date().toISOString();
-              const send = (data) => {
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+  Bun.serve({
+    port,
+    hostname: hostname2,
+    maxRequestBodySize: 1048576,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const { pathname } = url;
+      if (req.method === "OPTIONS") {
+        const origin = req.headers.get("origin");
+        const allowedOrigin = process.env["MEMENTOS_CORS_ORIGIN"] ?? "http://localhost:19428";
+        if (origin && origin !== allowedOrigin) {
+          return new Response(null, { status: 403 });
+        }
+        return new Response(null, { status: 204, headers: getCorsHeaders(req) });
+      }
+      if (pathname === "/api/health" || pathname === "/health") {
+        const profile = getActiveProfile();
+        const { createRequire: createRequire2 } = await import("module");
+        const req2 = createRequire2(import.meta.url);
+        const pkg = req2("../../package.json");
+        const db = getDatabase();
+        const total = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'active'").get().c;
+        const expired = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'expired' OR (expires_at IS NOT NULL AND expires_at < datetime('now'))").get().c;
+        const pinned = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'active' AND pinned = 1").get().c;
+        const agents = db.query("SELECT COUNT(*) as c FROM agents").get().c;
+        const projects = db.query("SELECT COUNT(*) as c FROM projects").get().c;
+        const status = expired > 50 ? "warn" : "ok";
+        return json({ status, version: pkg.version, profile: profile ?? "default", db_path: getDbPath(), hostname: hostname2, memories: { total, expired, pinned }, agents, projects });
+      }
+      if (pathname.startsWith("/api/") && pathname !== "/api/health") {
+        const authError = authenticateRequest(req);
+        if (authError)
+          return authError;
+      }
+      if (pathname === "/api/profile" && req.method === "GET") {
+        const profile = getActiveProfile();
+        return json({ active: profile ?? null, profiles: listProfiles(), db_path: getDbPath() });
+      }
+      if (pathname === "/api/memories/stream" && req.method === "GET") {
+        const stream = new ReadableStream({
+          start(controller) {
+            const encoder = new TextEncoder;
+            let lastSeen = new Date().toISOString();
+            const send = (data) => {
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
 
 `));
-              };
-              send({ type: "connected", timestamp: lastSeen });
-              const interval = setInterval(() => {
-                try {
-                  const db = getDatabase();
-                  const rows = db.query("SELECT * FROM memories WHERE updated_at > ? OR created_at > ? ORDER BY updated_at DESC LIMIT 50").all(lastSeen, lastSeen);
-                  if (rows.length > 0) {
-                    lastSeen = new Date().toISOString();
-                    send({ type: "memories", data: rows, count: rows.length });
-                  }
-                } catch {}
-              }, 1000);
-              req.signal.addEventListener("abort", () => {
-                clearInterval(interval);
-                controller.close();
-              });
-            }
-          });
-          return new Response(stream, {
-            headers: {
-              "Content-Type": "text/event-stream",
-              "Cache-Control": "no-cache",
-              Connection: "keep-alive",
-              ...CORS_HEADERS
-            }
-          });
-        }
-        const matched = matchRoute(req.method, pathname);
-        if (!matched) {
-          if (pathname.startsWith("/api/")) {
-            return errorResponse("Not found", 404);
+            };
+            send({ type: "connected", timestamp: lastSeen });
+            const interval = setInterval(() => {
+              try {
+                const db = getDatabase();
+                const rows = db.query("SELECT * FROM memories WHERE updated_at > ? OR created_at > ? ORDER BY updated_at DESC LIMIT 50").all(lastSeen, lastSeen);
+                if (rows.length > 0) {
+                  lastSeen = new Date().toISOString();
+                  send({ type: "memories", data: rows, count: rows.length });
+                }
+              } catch {}
+            }, 1000);
+            req.signal.addEventListener("abort", () => {
+              clearInterval(interval);
+              controller.close();
+            });
           }
-          const dashDir = resolveDashboardDir();
-          if (existsSync7(dashDir) && (req.method === "GET" || req.method === "HEAD")) {
-            if (pathname !== "/") {
-              const resolvedDash = resolve3(dashDir) + sep;
-              const requestedPath = resolve3(join8(dashDir, pathname));
-              if (requestedPath.startsWith(resolvedDash)) {
-                const staticRes = serveStaticFile(requestedPath);
-                if (staticRes)
-                  return staticRes;
-              }
-            }
-            const indexRes = serveStaticFile(join8(dashDir, "index.html"));
-            if (indexRes)
-              return indexRes;
+        });
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            ...CORS_HEADERS
           }
+        });
+      }
+      const matched = matchRoute(req.method, pathname);
+      if (!matched) {
+        if (pathname.startsWith("/api/")) {
           return errorResponse("Not found", 404);
         }
-        try {
-          return await matched.handler(req, url, matched.params);
-        } catch (e) {
-          console.error(`[mementos-serve] ${req.method} ${pathname}:`, e);
-          return errorResponse("Internal server error", 500);
+        const dashDir = resolveDashboardDir();
+        if (existsSync7(dashDir) && (req.method === "GET" || req.method === "HEAD")) {
+          if (pathname !== "/") {
+            const resolvedDash = resolve3(dashDir) + sep;
+            const requestedPath = resolve3(join8(dashDir, pathname));
+            if (requestedPath.startsWith(resolvedDash)) {
+              const staticRes = serveStaticFile(requestedPath);
+              if (staticRes)
+                return staticRes;
+            }
+          }
+          const indexRes = serveStaticFile(join8(dashDir, "index.html"));
+          if (indexRes)
+            return indexRes;
         }
+        return errorResponse("Not found", 404);
+      }
+      try {
+        return await matched.handler(req, url, matched.params);
+      } catch (e) {
+        console.error(`[mementos-serve] ${req.method} ${pathname}:`, e);
+        return errorResponse("Internal server error", 500);
       }
-    });
-    console.log(`Mementos server listening on http://${hostname2}:${port}`);
-  } catch (e) {
-    const err = e;
-    if (err.code === "EADDRINUSE" && attempt < maxRetries) {
-      const nextPort = port + attempt + 1;
-      console.log(`Port ${port} in use, trying ${nextPort}`);
-      startServer(nextPort, attempt + 1);
-    } else {
-      throw e;
     }
-  }
+  });
+  console.log(`Mementos server listening on http://${hostname2}:${port}`);
 }
 async function main() {
   if (hasFlag("--help", "-h")) {