@hasna/conversations 0.0.8 → 0.1.0

package/bin/index.js

@@ -1892,7 +1892,7 @@ function getDb() {
       session_id TEXT NOT NULL,
       from_agent TEXT NOT NULL,
       to_agent TEXT NOT NULL,
-      channel TEXT,
+      space TEXT,
       content TEXT NOT NULL,
       priority TEXT NOT NULL DEFAULT 'normal',
       working_dir TEXT,
@@ -1906,27 +1906,106 @@ function getDb() {
   db.exec("CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id)");
   db.exec("CREATE INDEX IF NOT EXISTS idx_messages_to ON messages(to_agent)");
   db.exec("CREATE INDEX IF NOT EXISTS idx_messages_created ON messages(created_at)");
-  db.exec("CREATE INDEX IF NOT EXISTS idx_messages_channel ON messages(channel)");
-  const cols = db.prepare("PRAGMA table_info(messages)").all();
-  if (!cols.some((c) => c.name === "channel")) {
-    db.exec("ALTER TABLE messages ADD COLUMN channel TEXT");
-  }
+  db.exec("CREATE INDEX IF NOT EXISTS idx_messages_space ON messages(space)");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT,
+      path TEXT,
+      created_by TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      metadata TEXT,
+      tags TEXT,
+      status TEXT NOT NULL DEFAULT 'active',
+      repository TEXT,
+      settings TEXT
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_projects_name ON projects(name)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_projects_status ON projects(status)");
   db.exec(`
-    CREATE TABLE IF NOT EXISTS channels (
+    CREATE TABLE IF NOT EXISTS spaces (
       name TEXT PRIMARY KEY,
       description TEXT,
+      parent_id TEXT REFERENCES spaces(name),
+      project_id TEXT REFERENCES projects(id),
       created_by TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now'))
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      archived_at TEXT
     )
   `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_spaces_parent ON spaces(parent_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_spaces_project ON spaces(project_id)");
   db.exec(`
-    CREATE TABLE IF NOT EXISTS channel_members (
-      channel TEXT NOT NULL REFERENCES channels(name),
+    CREATE TABLE IF NOT EXISTS space_members (
+      space TEXT NOT NULL REFERENCES spaces(name),
       agent TEXT NOT NULL,
       joined_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
-      PRIMARY KEY (channel, agent)
+      PRIMARY KEY (space, agent)
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_presence (
+      agent TEXT PRIMARY KEY,
+      status TEXT NOT NULL DEFAULT 'online',
+      last_seen_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      metadata TEXT
     )
   `);
+  const existingTables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+  const tableNames = existingTables.map((t) => t.name);
+  if (tableNames.includes("channels") && tableNames.includes("spaces")) {
+    const spaceCount = db.prepare("SELECT COUNT(*) as c FROM spaces").get().c;
+    const channelCount = db.prepare("SELECT COUNT(*) as c FROM channels").get().c;
+    if (channelCount > 0 && spaceCount === 0) {
+      db.exec("BEGIN");
+      try {
+        db.exec(`
+          INSERT OR IGNORE INTO spaces (name, description, created_by, created_at)
+          SELECT name, description, created_by, created_at FROM channels
+        `);
+        if (tableNames.includes("channel_members")) {
+          db.exec(`
+            INSERT OR IGNORE INTO space_members (space, agent, joined_at)
+            SELECT channel, agent, joined_at FROM channel_members
+          `);
+        }
+        db.exec("COMMIT");
+      } catch (e) {
+        db.exec("ROLLBACK");
+        throw e;
+      }
+    }
+    db.exec("DROP TABLE IF EXISTS channel_members");
+    db.exec("DROP TABLE IF EXISTS channels");
+  }
+  const msgCols = db.prepare("PRAGMA table_info(messages)").all();
+  const colNames = msgCols.map((c) => c.name);
+  if (colNames.includes("channel") && !colNames.includes("space")) {
+    db.exec("ALTER TABLE messages ADD COLUMN space TEXT");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_messages_space ON messages(space)");
+    db.exec("UPDATE messages SET space = channel WHERE channel IS NOT NULL");
+    db.exec(`
+      UPDATE messages
+      SET session_id = 'space:' || substr(session_id, 9)
+      WHERE session_id LIKE 'channel:%'
+    `);
+  }
+  const spaceCols = db.prepare("PRAGMA table_info(spaces)").all();
+  const spaceColNames = spaceCols.map((c) => c.name);
+  if (!spaceColNames.includes("archived_at")) {
+    db.exec("ALTER TABLE spaces ADD COLUMN archived_at TEXT");
+  }
+  const msgCols2 = db.prepare("PRAGMA table_info(messages)").all();
+  const colNames2 = msgCols2.map((c) => c.name);
+  if (!colNames2.includes("edited_at")) {
+    db.exec("ALTER TABLE messages ADD COLUMN edited_at TEXT");
+  }
+  if (!colNames2.includes("pinned_at")) {
+    db.exec("ALTER TABLE messages ADD COLUMN pinned_at TEXT");
+    db.exec("CREATE INDEX IF NOT EXISTS idx_messages_pinned ON messages(pinned_at)");
+  }
   return db;
 }
 function closeDb() {
@@ -1941,21 +2020,31 @@ var init_db = () => {};
 // src/lib/messages.ts
 import { randomUUID } from "crypto";
 function parseMessage(row) {
+  let metadata = null;
+  if (row.metadata) {
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = null;
+    }
+  }
   return {
     ...row,
-    metadata: row.metadata ? JSON.parse(row.metadata) : null
+    metadata
   };
 }
 function sendMessage(opts) {
   const db2 = getDb();
-  const sessionId = opts.session_id || `${[opts.from, opts.to].sort().join("-")}-${randomUUID().slice(0, 8)}`;
+  const explicitSession = opts.session_id && opts.session_id.trim().length > 0 ? opts.session_id : undefined;
+  const sessionId = explicitSession ?? (opts.space ? `space:${opts.space}` : `${[opts.from, opts.to].sort().join("-")}-${randomUUID().slice(0, 8)}`);
   const metadata = opts.metadata ? JSON.stringify(opts.metadata) : null;
+  const normalizedPriority = opts.priority === "low" || opts.priority === "normal" || opts.priority === "high" || opts.priority === "urgent" ? opts.priority : "normal";
   const stmt = db2.prepare(`
-    INSERT INTO messages (session_id, from_agent, to_agent, channel, content, priority, working_dir, repository, branch, metadata)
+    INSERT INTO messages (session_id, from_agent, to_agent, space, content, priority, working_dir, repository, branch, metadata)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     RETURNING *
   `);
-  const row = stmt.get(sessionId, opts.from, opts.to, opts.channel || null, opts.content, opts.priority || "normal", opts.working_dir || null, opts.repository || null, opts.branch || null, metadata);
+  const row = stmt.get(sessionId, opts.from, opts.to, opts.space || null, opts.content, normalizedPriority, opts.working_dir || null, opts.repository || null, opts.branch || null, metadata);
   return parseMessage(row);
 }
 function readMessages(opts = {}) {
@@ -1974,20 +2063,25 @@ function readMessages(opts = {}) {
     conditions.push("to_agent = ?");
     params.push(opts.to);
   }
-  if (opts.channel) {
-    conditions.push("channel = ?");
-    params.push(opts.channel);
+  if (opts.space) {
+    conditions.push("space = ?");
+    params.push(opts.space);
   }
   if (opts.since) {
     conditions.push("created_at > ?");
     params.push(opts.since);
   }
+  if (opts.since_id !== undefined) {
+    conditions.push("id > ?");
+    params.push(opts.since_id);
+  }
   if (opts.unread_only) {
     conditions.push("read_at IS NULL");
   }
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const limit = opts.limit ? `LIMIT ${opts.limit}` : "";
-  const rows = db2.prepare(`SELECT * FROM messages ${where} ORDER BY created_at ASC ${limit}`).all(...params);
+  const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? `LIMIT ${Math.floor(opts.limit)}` : "";
+  const order = opts.order?.toLowerCase() === "desc" ? "DESC" : "ASC";
+  const rows = db2.prepare(`SELECT * FROM messages ${where} ORDER BY created_at ${order}, id ${order} ${limit}`).all(...params);
   return rows.map(parseMessage);
 }
 function markRead(ids, reader) {
@@ -2005,10 +2099,10 @@ function markSessionRead(sessionId, reader) {
   const result = stmt.run(sessionId, reader);
   return result.changes;
 }
-function markChannelRead(channelName, reader) {
+function markSpaceRead(spaceName, reader) {
   const db2 = getDb();
-  const stmt = db2.prepare(`UPDATE messages SET read_at = strftime('%Y-%m-%dT%H:%M:%f', 'now') WHERE channel = ? AND from_agent != ? AND read_at IS NULL`);
-  const result = stmt.run(channelName, reader);
+  const stmt = db2.prepare(`UPDATE messages SET read_at = strftime('%Y-%m-%dT%H:%M:%f', 'now') WHERE space = ? AND from_agent != ? AND read_at IS NULL`);
+  const result = stmt.run(spaceName, reader);
   return result.changes;
 }
 function getMessageById(id) {
@@ -2016,6 +2110,130 @@ function getMessageById(id) {
   const row = db2.prepare("SELECT * FROM messages WHERE id = ?").get(id);
   return row ? parseMessage(row) : null;
 }
+function markAllRead(agent) {
+  const db2 = getDb();
+  const stmt = db2.prepare(`UPDATE messages SET read_at = strftime('%Y-%m-%dT%H:%M:%f', 'now') WHERE to_agent = ? AND read_at IS NULL`);
+  const result = stmt.run(agent);
+  return result.changes;
+}
+function escapeCsvField(value) {
+  if (value === null || value === undefined)
+    return "";
+  const str = String(value);
+  if (str.includes(",") || str.includes('"') || str.includes(`
+`) || str.includes("\r")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function exportMessages(opts) {
+  const db2 = getDb();
+  const conditions = [];
+  const params = [];
+  if (opts?.space) {
+    conditions.push("space = ?");
+    params.push(opts.space);
+  }
+  if (opts?.session_id) {
+    conditions.push("session_id = ?");
+    params.push(opts.session_id);
+  }
+  if (opts?.from) {
+    conditions.push("from_agent = ?");
+    params.push(opts.from);
+  }
+  if (opts?.since) {
+    conditions.push("created_at >= ?");
+    params.push(opts.since);
+  }
+  if (opts?.until) {
+    conditions.push("created_at <= ?");
+    params.push(opts.until);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db2.prepare(`SELECT * FROM messages ${where} ORDER BY created_at ASC, id ASC`).all(...params);
+  const messages = rows.map(parseMessage);
+  const format = opts?.format ?? "json";
+  if (format === "csv") {
+    const headers = "id,session_id,from_agent,to_agent,space,content,priority,created_at,read_at";
+    const lines = messages.map((m) => [
+      String(m.id),
+      escapeCsvField(m.session_id),
+      escapeCsvField(m.from_agent),
+      escapeCsvField(m.to_agent),
+      escapeCsvField(m.space),
+      escapeCsvField(m.content),
+      escapeCsvField(m.priority),
+      escapeCsvField(m.created_at),
+      escapeCsvField(m.read_at)
+    ].join(","));
+    return [headers, ...lines].join(`
+`);
+  }
+  return JSON.stringify(messages, null, 2);
+}
+function deleteMessage(id, agent) {
+  const db2 = getDb();
+  const stmt = db2.prepare("DELETE FROM messages WHERE id = ? AND from_agent = ?");
+  const result = stmt.run(id, agent);
+  return result.changes > 0;
+}
+function editMessage(id, agent, newContent) {
+  const db2 = getDb();
+  const stmt = db2.prepare(`UPDATE messages SET content = ?, edited_at = strftime('%Y-%m-%dT%H:%M:%f', 'now') WHERE id = ? AND from_agent = ? RETURNING *`);
+  const row = stmt.get(newContent, id, agent);
+  return row ? parseMessage(row) : null;
+}
+function pinMessage(id) {
+  const db2 = getDb();
+  const stmt = db2.prepare(`UPDATE messages SET pinned_at = strftime('%Y-%m-%dT%H:%M:%f', 'now') WHERE id = ? RETURNING *`);
+  const row = stmt.get(id);
+  return row ? parseMessage(row) : null;
+}
+function unpinMessage(id) {
+  const db2 = getDb();
+  const stmt = db2.prepare(`UPDATE messages SET pinned_at = NULL WHERE id = ? RETURNING *`);
+  const row = stmt.get(id);
+  return row ? parseMessage(row) : null;
+}
+function getPinnedMessages(opts) {
+  const db2 = getDb();
+  const conditions = ["pinned_at IS NOT NULL"];
+  const params = [];
+  if (opts?.space) {
+    conditions.push("space = ?");
+    params.push(opts.space);
+  }
+  if (opts?.session_id) {
+    conditions.push("session_id = ?");
+    params.push(opts.session_id);
+  }
+  const where = `WHERE ${conditions.join(" AND ")}`;
+  const limit = Number.isFinite(opts?.limit) && opts.limit > 0 ? `LIMIT ${Math.floor(opts.limit)}` : "";
+  const rows = db2.prepare(`SELECT * FROM messages ${where} ORDER BY pinned_at DESC, id DESC ${limit}`).all(...params);
+  return rows.map(parseMessage);
+}
+function searchMessages(opts) {
+  const db2 = getDb();
+  const conditions = ["content LIKE ?"];
+  const params = [`%${opts.query}%`];
+  if (opts.space) {
+    conditions.push("space = ?");
+    params.push(opts.space);
+  }
+  if (opts.from) {
+    conditions.push("from_agent = ?");
+    params.push(opts.from);
+  }
+  if (opts.to) {
+    conditions.push("to_agent = ?");
+    params.push(opts.to);
+  }
+  const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? Math.floor(opts.limit) : 50;
+  const where = `WHERE ${conditions.join(" AND ")}`;
+  const rows = db2.prepare(`SELECT * FROM messages ${where} ORDER BY created_at DESC, id DESC LIMIT ${limit}`).all(...params);
+  return rows.map(parseMessage);
+}
 var init_messages = __esm(() => {
   init_db();
 });
@@ -2053,73 +2271,493 @@ var init_sessions = __esm(() => {
   init_db();
 });
 
-// src/lib/channels.ts
-function createChannel(name, createdBy, description) {
+// src/lib/spaces.ts
+function getSpaceDepth(spaceName) {
+  const db2 = getDb();
+  let depth = 0;
+  let current = spaceName;
+  for (let i = 0;i < 10; i++) {
+    const row = db2.prepare("SELECT parent_id FROM spaces WHERE name = ?").get(current);
+    if (!row || !row.parent_id)
+      break;
+    depth++;
+    current = row.parent_id;
+  }
+  return depth;
+}
+function createSpace(name, createdBy, options) {
   const db2 = getDb();
-  const row = db2.prepare("INSERT INTO channels (name, description, created_by) VALUES (?, ?, ?) RETURNING *").get(name, description || null, createdBy);
-  db2.prepare("INSERT OR IGNORE INTO channel_members (channel, agent) VALUES (?, ?)").run(name, createdBy);
+  if (options?.parent_id) {
+    const parentExists = db2.prepare("SELECT name FROM spaces WHERE name = ?").get(options.parent_id);
+    if (!parentExists) {
+      throw new Error(`Parent space not found: ${options.parent_id}`);
+    }
+    const parentDepth = getSpaceDepth(options.parent_id);
+    if (parentDepth >= 2) {
+      throw new Error("Maximum space nesting depth is 3 levels");
+    }
+  }
+  if (options?.project_id) {
+    const projectExists = db2.prepare("SELECT id FROM projects WHERE id = ?").get(options.project_id);
+    if (!projectExists) {
+      throw new Error(`Project not found: ${options.project_id}`);
+    }
+  }
+  const row = db2.prepare("INSERT INTO spaces (name, description, parent_id, project_id, created_by) VALUES (?, ?, ?, ?, ?) RETURNING *").get(name, options?.description || null, options?.parent_id || null, options?.project_id || null, createdBy);
+  db2.prepare("INSERT OR IGNORE INTO space_members (space, agent) VALUES (?, ?)").run(name, createdBy);
   return row;
 }
-function listChannels() {
+function listSpaces(options) {
   const db2 = getDb();
+  const conditions = [];
+  const params = [];
+  if (options?.project_id) {
+    conditions.push("s.project_id = ?");
+    params.push(options.project_id);
+  }
+  if (options?.parent_id !== undefined) {
+    if (options.parent_id === null) {
+      conditions.push("s.parent_id IS NULL");
+    } else {
+      conditions.push("s.parent_id = ?");
+      params.push(options.parent_id);
+    }
+  }
+  if (!options?.include_archived) {
+    conditions.push("s.archived_at IS NULL");
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const rows = db2.prepare(`
     SELECT
-      c.name,
-      c.description,
-      c.created_by,
-      c.created_at,
-      (SELECT COUNT(*) FROM channel_members WHERE channel = c.name) AS member_count,
-      (SELECT COUNT(*) FROM messages WHERE channel = c.name) AS message_count
-    FROM channels c
-    ORDER BY c.name ASC
-  `).all();
+      s.name,
+      s.description,
+      s.parent_id,
+      s.project_id,
+      s.created_by,
+      s.created_at,
+      s.archived_at,
+      (SELECT COUNT(*) FROM space_members WHERE space = s.name) AS member_count,
+      (SELECT COUNT(*) FROM messages WHERE space = s.name) AS message_count
+    FROM spaces s
+    ${where}
+    ORDER BY s.name ASC
+  `).all(...params);
   return rows;
 }
-function getChannel(name) {
+function getSpace(name) {
   const db2 = getDb();
   const row = db2.prepare(`
     SELECT
-      c.name,
-      c.description,
-      c.created_by,
-      c.created_at,
-      (SELECT COUNT(*) FROM channel_members WHERE channel = c.name) AS member_count,
-      (SELECT COUNT(*) FROM messages WHERE channel = c.name) AS message_count
-    FROM channels c
-    WHERE c.name = ?
+      s.name,
+      s.description,
+      s.parent_id,
+      s.project_id,
+      s.created_by,
+      s.created_at,
+      s.archived_at,
+      (SELECT COUNT(*) FROM space_members WHERE space = s.name) AS member_count,
+      (SELECT COUNT(*) FROM messages WHERE space = s.name) AS message_count
+    FROM spaces s
+    WHERE s.name = ?
   `).get(name);
   return row;
 }
-function joinChannel(channelName, agent) {
+function joinSpace(spaceName, agent) {
   const db2 = getDb();
-  const channel = db2.prepare("SELECT name FROM channels WHERE name = ?").get(channelName);
-  if (!channel)
+  const space = db2.prepare("SELECT name FROM spaces WHERE name = ?").get(spaceName);
+  if (!space)
     return false;
-  db2.prepare("INSERT OR IGNORE INTO channel_members (channel, agent) VALUES (?, ?)").run(channelName, agent);
+  db2.prepare("INSERT OR IGNORE INTO space_members (space, agent) VALUES (?, ?)").run(spaceName, agent);
   return true;
 }
-function leaveChannel(channelName, agent) {
+function leaveSpace(spaceName, agent) {
   const db2 = getDb();
-  const result = db2.prepare("DELETE FROM channel_members WHERE channel = ? AND agent = ?").run(channelName, agent);
+  const result = db2.prepare("DELETE FROM space_members WHERE space = ? AND agent = ?").run(spaceName, agent);
   return result.changes > 0;
 }
-function getChannelMembers(channelName) {
+function getSpaceMembers(spaceName) {
+  const db2 = getDb();
+  return db2.prepare("SELECT space, agent, joined_at FROM space_members WHERE space = ? ORDER BY joined_at ASC").all(spaceName);
+}
+function updateSpace(name, updates) {
+  const db2 = getDb();
+  const existing = db2.prepare("SELECT * FROM spaces WHERE name = ?").get(name);
+  if (!existing) {
+    throw new Error(`Space not found: ${name}`);
+  }
+  if (updates.parent_id !== undefined && updates.parent_id !== existing.parent_id) {
+    if (updates.parent_id !== null) {
+      const parentExists = db2.prepare("SELECT name FROM spaces WHERE name = ?").get(updates.parent_id);
+      if (!parentExists) {
+        throw new Error(`Parent space not found: ${updates.parent_id}`);
+      }
+      const parentDepth = getSpaceDepth(updates.parent_id);
+      if (parentDepth >= 2) {
+        throw new Error("Maximum space nesting depth is 3 levels");
+      }
+      if (updates.parent_id === name) {
+        throw new Error("A space cannot be its own parent");
+      }
+    }
+  }
+  if (updates.project_id !== undefined && updates.project_id !== existing.project_id) {
+    if (updates.project_id !== null) {
+      const projectExists = db2.prepare("SELECT id FROM projects WHERE id = ?").get(updates.project_id);
+      if (!projectExists) {
+        throw new Error(`Project not found: ${updates.project_id}`);
+      }
+    }
+  }
+  const sets = [];
+  const params = [];
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    params.push(updates.description);
+  }
+  if (updates.parent_id !== undefined) {
+    sets.push("parent_id = ?");
+    params.push(updates.parent_id);
+  }
+  if (updates.project_id !== undefined) {
+    sets.push("project_id = ?");
+    params.push(updates.project_id);
+  }
+  if (sets.length === 0) {
+    return existing;
+  }
+  params.push(name);
+  const row = db2.prepare(`UPDATE spaces SET ${sets.join(", ")} WHERE name = ? RETURNING *`).get(...params);
+  return row;
+}
+function archiveSpace(name) {
+  const db2 = getDb();
+  const existing = db2.prepare("SELECT * FROM spaces WHERE name = ?").get(name);
+  if (!existing) {
+    throw new Error(`Space not found: ${name}`);
+  }
+  const row = db2.prepare("UPDATE spaces SET archived_at = strftime('%Y-%m-%dT%H:%M:%f', 'now') WHERE name = ? RETURNING *").get(name);
+  return row;
+}
+function unarchiveSpace(name) {
+  const db2 = getDb();
+  const existing = db2.prepare("SELECT * FROM spaces WHERE name = ?").get(name);
+  if (!existing) {
+    throw new Error(`Space not found: ${name}`);
+  }
+  const row = db2.prepare("UPDATE spaces SET archived_at = NULL WHERE name = ? RETURNING *").get(name);
+  return row;
+}
+var init_spaces = __esm(() => {
+  init_db();
+});
+
+// src/lib/projects.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function parseProject(row) {
+  let metadata = null;
+  if (row.metadata) {
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = null;
+    }
+  }
+  let tags = [];
+  if (row.tags) {
+    try {
+      tags = JSON.parse(row.tags);
+    } catch {
+      tags = [];
+    }
+  }
+  let settings = null;
+  if (row.settings) {
+    try {
+      settings = JSON.parse(row.settings);
+    } catch {
+      settings = null;
+    }
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description || null,
+    path: row.path || null,
+    created_by: row.created_by,
+    created_at: row.created_at,
+    metadata,
+    tags,
+    status: row.status || "active",
+    repository: row.repository || null,
+    settings
+  };
+}
+function createProject(opts) {
+  const db2 = getDb();
+  const id = randomUUID2();
+  const metadata = opts.metadata ? JSON.stringify(opts.metadata) : null;
+  const tags = opts.tags ? JSON.stringify(opts.tags) : null;
+  const settings = opts.settings ? JSON.stringify(opts.settings) : null;
+  const row = db2.prepare(`
+    INSERT INTO projects (id, name, description, path, created_by, metadata, tags, repository, settings)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    RETURNING *
+  `).get(id, opts.name, opts.description || null, opts.path || null, opts.created_by, metadata, tags, opts.repository || null, settings);
+  return parseProject(row);
+}
+function listProjects(opts) {
+  const db2 = getDb();
+  const conditions = [];
+  const params = [];
+  if (opts?.status) {
+    conditions.push("p.status = ?");
+    params.push(opts.status);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db2.prepare(`
+    SELECT
+      p.*,
+      (SELECT COUNT(*) FROM spaces WHERE project_id = p.id) AS space_count
+    FROM projects p
+    ${where}
+    ORDER BY p.name ASC
+  `).all(...params);
+  return rows.map((row) => ({
+    ...parseProject(row),
+    space_count: row.space_count
+  }));
+}
+function getProject(id) {
+  const db2 = getDb();
+  const row = db2.prepare(`
+    SELECT
+      p.*,
+      (SELECT COUNT(*) FROM spaces WHERE project_id = p.id) AS space_count
+    FROM projects p
+    WHERE p.id = ?
+  `).get(id);
+  if (!row)
+    return null;
+  return {
+    ...parseProject(row),
+    space_count: row.space_count
+  };
+}
+function getProjectByName(name) {
+  const db2 = getDb();
+  const row = db2.prepare(`
+    SELECT
+      p.*,
+      (SELECT COUNT(*) FROM spaces WHERE project_id = p.id) AS space_count
+    FROM projects p
+    WHERE p.name = ?
+  `).get(name);
+  if (!row)
+    return null;
+  return {
+    ...parseProject(row),
+    space_count: row.space_count
+  };
+}
+function updateProject(id, updates) {
+  const db2 = getDb();
+  const existing = db2.prepare("SELECT * FROM projects WHERE id = ?").get(id);
+  if (!existing) {
+    throw new Error(`Project not found: ${id}`);
+  }
+  const sets = [];
+  const params = [];
+  if (updates.name !== undefined) {
+    sets.push("name = ?");
+    params.push(updates.name);
+  }
+  if (updates.description !== undefined) {
+    sets.push("description = ?");
+    params.push(updates.description);
+  }
+  if (updates.path !== undefined) {
+    sets.push("path = ?");
+    params.push(updates.path);
+  }
+  if (updates.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(updates.metadata));
+  }
+  if (updates.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(updates.tags));
+  }
+  if (updates.status !== undefined) {
+    sets.push("status = ?");
+    params.push(updates.status);
+  }
+  if (updates.repository !== undefined) {
+    sets.push("repository = ?");
+    params.push(updates.repository);
+  }
+  if (updates.settings !== undefined) {
+    sets.push("settings = ?");
+    params.push(JSON.stringify(updates.settings));
+  }
+  if (sets.length === 0) {
+    return parseProject(existing);
+  }
+  params.push(id);
+  const row = db2.prepare(`UPDATE projects SET ${sets.join(", ")} WHERE id = ? RETURNING *`).get(...params);
+  return parseProject(row);
+}
+function deleteProject(id) {
   const db2 = getDb();
-  return db2.prepare("SELECT channel, agent, joined_at FROM channel_members WHERE channel = ? ORDER BY joined_at ASC").all(channelName);
+  const spaceCount = db2.prepare("SELECT COUNT(*) as c FROM spaces WHERE project_id = ?").get(id).c;
+  if (spaceCount > 0) {
+    throw new Error(`Cannot delete project: ${spaceCount} space(s) still reference it`);
+  }
+  const result = db2.prepare("DELETE FROM projects WHERE id = ?").run(id);
+  return result.changes > 0;
 }
-var init_channels = __esm(() => {
+var init_projects = __esm(() => {
   init_db();
 });
 
 // src/lib/identity.ts
 function resolveIdentity(explicit) {
-  if (explicit)
-    return explicit;
-  if (process.env.CONVERSATIONS_AGENT_ID)
-    return process.env.CONVERSATIONS_AGENT_ID;
+  const explicitValue = explicit?.trim();
+  if (explicitValue)
+    return explicitValue;
+  const envValue = process.env.CONVERSATIONS_AGENT_ID?.trim();
+  if (envValue)
+    return envValue;
   return "user";
 }
 
+// src/lib/presence.ts
+function parsePresence(row) {
+  let metadata = null;
+  if (row.metadata) {
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = null;
+    }
+  }
+  const lastSeenAt = row.last_seen_at;
+  const lastSeenMs = new Date(lastSeenAt + "Z").getTime();
+  const nowMs = Date.now();
+  const online = nowMs - lastSeenMs < ONLINE_THRESHOLD_SECONDS * 1000;
+  return {
+    agent: row.agent,
+    status: row.status,
+    last_seen_at: lastSeenAt,
+    online,
+    metadata
+  };
+}
+function heartbeat(agent, status, metadata) {
+  const db2 = getDb();
+  const metadataJson = metadata ? JSON.stringify(metadata) : null;
+  const resolvedStatus = status || "online";
+  db2.prepare(`
+    INSERT INTO agent_presence (agent, status, last_seen_at, metadata)
+    VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%f', 'now'), ?)
+    ON CONFLICT(agent) DO UPDATE SET
+      status = excluded.status,
+      last_seen_at = excluded.last_seen_at,
+      metadata = excluded.metadata
+  `).run(agent, resolvedStatus, metadataJson);
+}
+function listAgents(opts) {
+  const db2 = getDb();
+  let query = "SELECT * FROM agent_presence";
+  const params = [];
+  if (opts?.online_only) {
+    query += " WHERE last_seen_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-60 seconds')";
+  }
+  query += " ORDER BY last_seen_at DESC";
+  const rows = db2.prepare(query).all(...params);
+  return rows.map(parsePresence);
+}
+var ONLINE_THRESHOLD_SECONDS = 60;
+var init_presence = __esm(() => {
+  init_db();
+});
+
+// package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "@hasna/conversations",
+    version: "0.1.0",
+    description: "Real-time CLI messaging for AI agents",
+    type: "module",
+    bin: {
+      conversations: "bin/index.js",
+      "conversations-mcp": "bin/mcp.js"
+    },
+    exports: {
+      ".": {
+        import: "./dist/index.js",
+        types: "./dist/index.d.ts"
+      }
+    },
+    files: [
+      "dist/",
+      "bin/",
+      "dashboard/dist/",
+      "LICENSE",
+      "README.md"
+    ],
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    scripts: {
+      build: "bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+      "build:dashboard": "cd dashboard && bun install && bun run build",
+      test: "bun test",
+      dev: "bun run ./src/cli/index.tsx",
+      typecheck: "tsc --noEmit",
+      prepublishOnly: "bun run build"
+    },
+    keywords: [
+      "conversations",
+      "messaging",
+      "ai",
+      "agent",
+      "cli",
+      "typescript",
+      "bun",
+      "claude",
+      "mcp"
+    ],
+    author: "Hasna",
+    license: "Apache-2.0",
+    devDependencies: {
+      "@types/bun": "latest",
+      "@types/react": "^18.2.0",
+      typescript: "^5"
+    },
+    dependencies: {
+      "@modelcontextprotocol/sdk": "^1.26.0",
+      chalk: "^5.3.0",
+      commander: "^12.1.0",
+      ink: "^5.0.1",
+      "ink-select-input": "^6.0.0",
+      "ink-spinner": "^5.0.0",
+      "ink-text-input": "^6.0.0",
+      react: "^18.2.0",
+      zod: "^4.3.6"
+    },
+    engines: {
+      bun: ">=1.0.0"
+    },
+    publishConfig: {
+      registry: "https://registry.npmjs.org",
+      access: "public"
+    },
+    repository: {
+      type: "git",
+      url: "git+https://github.com/hasna/conversations.git"
+    }
+  };
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
@@ -29410,7 +30048,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time3(str) {
+    return function time(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -31002,10 +31640,12 @@ var init_mcp2 = __esm(() => {
   init_zod();
   init_messages();
   init_sessions();
-  init_channels();
+  init_spaces();
+  init_projects();
+  init_presence();
   server = new McpServer({
     name: "conversations",
-    version: "0.0.8"
+    version: "0.1.0"
   });
   server.registerTool("send_message", {
     title: "Send Message",
@@ -31022,7 +31662,17 @@ var init_mcp2 = __esm(() => {
     }
   }, async ({ to, content, session_id, priority, working_dir, repository, branch, metadata }) => {
     const from = resolveIdentity();
-    const parsedMetadata = metadata ? JSON.parse(metadata) : undefined;
+    let parsedMetadata;
+    if (metadata) {
+      try {
+        parsedMetadata = JSON.parse(metadata);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Invalid metadata JSON." }],
+          isError: true
+        };
+      }
+    }
     const msg = sendMessage({
       from,
       to,
@@ -31045,7 +31695,7 @@ var init_mcp2 = __esm(() => {
       session_id: exports_external.string().optional().describe("Filter by session ID"),
       from: exports_external.string().optional().describe("Filter by sender agent ID"),
       to: exports_external.string().optional().describe("Filter by recipient agent ID"),
-      channel: exports_external.string().optional().describe("Filter by channel name"),
+      space: exports_external.string().optional().describe("Filter by space name"),
       since: exports_external.string().optional().describe("Messages after this ISO timestamp"),
       limit: exports_external.number().optional().describe("Max messages to return"),
       unread_only: exports_external.boolean().optional().describe("Only return unread messages")
@@ -31085,12 +31735,15 @@ var init_mcp2 = __esm(() => {
       };
     }
     const from = resolveIdentity();
+    const space = original.space || (original.session_id?.startsWith("space:") ? original.session_id.slice(6) : undefined);
+    const to = space ? space : original.from_agent === from ? original.to_agent : original.from_agent;
     const msg = sendMessage({
       from,
-      to: original.from_agent,
+      to,
       content,
       session_id: original.session_id,
-      priority
+      priority,
+      space
     });
     return {
       content: [{ type: "text", text: JSON.stringify(msg, null, 2) }]
@@ -31098,145 +31751,612 @@ var init_mcp2 = __esm(() => {
   });
   server.registerTool("mark_read", {
     title: "Mark Read",
-    description: "Mark message IDs as read for the current agent.",
+    description: "Mark message IDs as read for the current agent. Set 'all' to true to mark all unread messages as read.",
     inputSchema: {
-      ids: exports_external.array(exports_external.number()).describe("Message IDs to mark as read")
+      ids: exports_external.array(exports_external.number()).optional().describe("Message IDs to mark as read"),
+      all: exports_external.boolean().optional().describe("Mark all unread messages as read")
     }
-  }, async ({ ids }) => {
+  }, async ({ ids, all }) => {
     const agent = resolveIdentity();
-    const count = markRead(ids, agent);
+    let count;
+    if (all) {
+      count = markAllRead(agent);
+    } else if (ids && ids.length > 0) {
+      count = markRead(ids, agent);
+    } else {
+      return {
+        content: [{ type: "text", text: "Provide message IDs or set 'all' to true." }],
+        isError: true
+      };
+    }
     return {
       content: [{ type: "text", text: JSON.stringify({ marked_read: count }, null, 2) }]
     };
   });
-  server.registerTool("create_channel", {
-    title: "Create Channel",
-    description: "Create a new channel. The creator is auto-joined.",
+  server.registerTool("search_messages", {
+    title: "Search Messages",
+    description: "Full-text search across message content. Returns matching messages ordered by newest first.",
+    inputSchema: {
+      query: exports_external.string().describe("Search query string"),
+      space: exports_external.string().optional().describe("Filter by space name"),
+      from: exports_external.string().optional().describe("Filter by sender agent ID"),
+      to: exports_external.string().optional().describe("Filter by recipient agent ID"),
+      limit: exports_external.number().optional().describe("Max results to return (default 50)")
+    }
+  }, async ({ query, space, from, to, limit }) => {
+    const messages = searchMessages({ query, space, from, to, limit });
+    return {
+      content: [{ type: "text", text: JSON.stringify(messages, null, 2) }]
+    };
+  });
+  server.registerTool("export_messages", {
+    title: "Export Messages",
+    description: "Export messages as JSON or CSV with optional filters.",
+    inputSchema: {
+      space: exports_external.string().optional().describe("Filter by space name"),
+      session_id: exports_external.string().optional().describe("Filter by session ID"),
+      from: exports_external.string().optional().describe("Filter by sender agent ID"),
+      since: exports_external.string().optional().describe("Messages after this ISO date"),
+      until: exports_external.string().optional().describe("Messages before this ISO date"),
+      format: exports_external.enum(["json", "csv"]).optional().describe("Output format (default: json)")
+    }
+  }, async ({ space, session_id, from, since, until, format }) => {
+    const result = exportMessages({ space, session_id, from, since, until, format });
+    return {
+      content: [{ type: "text", text: result }]
+    };
+  });
+  server.registerTool("create_space", {
+    title: "Create Space",
+    description: "Create a new space. The creator is auto-joined. Spaces can be nested (max 3 levels) and associated with a project.",
     inputSchema: {
-      name: exports_external.string().describe("Channel name (e.g. 'deployments', 'code-review')"),
-      description: exports_external.string().optional().describe("Channel description")
+      name: exports_external.string().describe("Space name (e.g. 'deployments', 'code-review')"),
+      description: exports_external.string().optional().describe("Space description"),
+      parent_id: exports_external.string().optional().describe("Parent space name for nesting (max 3 levels deep)"),
+      project_id: exports_external.string().optional().describe("Project ID to associate this space with")
     }
-  }, async ({ name, description }) => {
+  }, async ({ name, description, parent_id, project_id }) => {
     const agent = resolveIdentity();
     try {
-      const ch = createChannel(name, agent, description);
+      const sp = createSpace(name, agent, { description, parent_id, project_id });
       return {
-        content: [{ type: "text", text: JSON.stringify(ch, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(sp, null, 2) }]
       };
     } catch (e) {
       if (e.message?.includes("UNIQUE constraint")) {
         return {
-          content: [{ type: "text", text: `Channel #${name} already exists` }],
+          content: [{ type: "text", text: `Space #${name} already exists` }],
           isError: true
         };
       }
-      throw e;
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true
+      };
     }
   });
-  server.registerTool("list_channels", {
-    title: "List Channels",
-    description: "List all available channels with member and message counts."
-  }, async () => {
-    const channels = listChannels();
+  server.registerTool("list_spaces", {
+    title: "List Spaces",
+    description: "List all available spaces with member and message counts. Can filter by project or parent. Archived spaces are excluded by default.",
+    inputSchema: {
+      project_id: exports_external.string().optional().describe("Filter by project ID"),
+      parent_id: exports_external.string().optional().describe("Filter by parent space name. Use 'null' for top-level only."),
+      include_archived: exports_external.boolean().optional().describe("Include archived spaces (default: false)")
+    }
+  }, async ({ project_id, parent_id, include_archived }) => {
+    const opts = {};
+    if (project_id)
+      opts.project_id = project_id;
+    if (parent_id === "null") {
+      opts.parent_id = null;
+    } else if (parent_id) {
+      opts.parent_id = parent_id;
+    }
+    if (include_archived)
+      opts.include_archived = true;
+    const spaces = listSpaces(opts);
     return {
-      content: [{ type: "text", text: JSON.stringify(channels, null, 2) }]
+      content: [{ type: "text", text: JSON.stringify(spaces, null, 2) }]
     };
   });
-  server.registerTool("send_to_channel", {
-    title: "Send to Channel",
-    description: "Send a message to a channel. All members can see it.",
+  server.registerTool("send_to_space", {
+    title: "Send to Space",
+    description: "Send a message to a space. All members can see it.",
     inputSchema: {
-      channel: exports_external.string().describe("Channel name"),
+      space: exports_external.string().describe("Space name"),
       content: exports_external.string().describe("Message content"),
       priority: exports_external.enum(["low", "normal", "high", "urgent"]).optional().describe("Message priority")
     }
-  }, async ({ channel, content, priority }) => {
+  }, async ({ space, content, priority }) => {
     const from = resolveIdentity();
-    const ch = getChannel(channel);
-    if (!ch) {
+    const sp = getSpace(space);
+    if (!sp) {
       return {
-        content: [{ type: "text", text: `Channel #${channel} not found` }],
+        content: [{ type: "text", text: `Space #${space} not found` }],
         isError: true
       };
     }
     const msg = sendMessage({
       from,
-      to: channel,
+      to: space,
       content,
-      channel,
-      session_id: `channel:${channel}`,
+      space,
+      session_id: `space:${space}`,
       priority
     });
     return {
       content: [{ type: "text", text: JSON.stringify(msg, null, 2) }]
     };
   });
-  server.registerTool("read_channel", {
-    title: "Read Channel",
-    description: "Read messages from a channel.",
+  server.registerTool("read_space", {
+    title: "Read Space",
+    description: "Read messages from a space.",
     inputSchema: {
-      channel: exports_external.string().describe("Channel name"),
+      space: exports_external.string().describe("Space name"),
       since: exports_external.string().optional().describe("Messages after this ISO timestamp"),
       limit: exports_external.number().optional().describe("Max messages to return")
     }
-  }, async ({ channel, since, limit }) => {
-    const messages = readMessages({ channel, since, limit });
+  }, async ({ space, since, limit }) => {
+    const messages = readMessages({ space, since, limit });
     return {
       content: [{ type: "text", text: JSON.stringify(messages, null, 2) }]
     };
   });
-  server.registerTool("join_channel", {
-    title: "Join Channel",
-    description: "Join a channel to receive messages.",
+  server.registerTool("join_space", {
+    title: "Join Space",
+    description: "Join a space to receive messages.",
     inputSchema: {
-      channel: exports_external.string().describe("Channel name to join")
+      space: exports_external.string().describe("Space name to join")
     }
-  }, async ({ channel }) => {
+  }, async ({ space }) => {
     const agent = resolveIdentity();
-    const ok = joinChannel(channel, agent);
+    const ok = joinSpace(space, agent);
     if (!ok) {
       return {
-        content: [{ type: "text", text: `Channel #${channel} not found` }],
+        content: [{ type: "text", text: `Space #${space} not found` }],
         isError: true
       };
     }
     return {
-      content: [{ type: "text", text: JSON.stringify({ channel, agent, joined: true }, null, 2) }]
+      content: [{ type: "text", text: JSON.stringify({ space, agent, joined: true }, null, 2) }]
     };
   });
-  server.registerTool("leave_channel", {
-    title: "Leave Channel",
-    description: "Leave a channel.",
+  server.registerTool("leave_space", {
+    title: "Leave Space",
+    description: "Leave a space.",
     inputSchema: {
-      channel: exports_external.string().describe("Channel name to leave")
+      space: exports_external.string().describe("Space name to leave")
     }
-  }, async ({ channel }) => {
+  }, async ({ space }) => {
     const agent = resolveIdentity();
-    const left = leaveChannel(channel, agent);
+    const left = leaveSpace(space, agent);
     return {
-      content: [{ type: "text", text: JSON.stringify({ channel, agent, left }, null, 2) }]
+      content: [{ type: "text", text: JSON.stringify({ space, agent, left }, null, 2) }]
     };
   });
-  isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("mcp.js") || process.argv[1]?.endsWith("mcp.ts");
-  if (isDirectRun) {
-    startMcpServer().catch((error48) => {
-      console.error("MCP server error:", error48);
-      process.exit(1);
-    });
-  }
-});
-
-// src/server/serve.ts
-var exports_serve = {};
-__export(exports_serve, {
-  startDashboardServer: () => startDashboardServer
+  server.registerTool("update_space", {
+    title: "Update Space",
+    description: "Update a space's description, parent, or project association.",
+    inputSchema: {
+      name: exports_external.string().describe("Space name to update"),
+      description: exports_external.string().optional().describe("New description"),
+      parent_id: exports_external.string().optional().describe("New parent space name (use 'null' to remove parent)"),
+      project_id: exports_external.string().optional().describe("New project ID (use 'null' to remove project)")
+    }
+  }, async ({ name, description, parent_id, project_id }) => {
+    const updates = {};
+    if (description !== undefined)
+      updates.description = description;
+    if (parent_id !== undefined)
+      updates.parent_id = parent_id === "null" ? null : parent_id;
+    if (project_id !== undefined)
+      updates.project_id = project_id === "null" ? null : project_id;
+    try {
+      const sp = updateSpace(name, updates);
+      return {
+        content: [{ type: "text", text: JSON.stringify(sp, null, 2) }]
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("archive_space", {
+    title: "Archive Space",
+    description: "Archive a space. Archived spaces are hidden from list by default.",
+    inputSchema: {
+      name: exports_external.string().describe("Space name to archive")
+    }
+  }, async ({ name }) => {
+    try {
+      const sp = archiveSpace(name);
+      return {
+        content: [{ type: "text", text: JSON.stringify(sp, null, 2) }]
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("unarchive_space", {
+    title: "Unarchive Space",
+    description: "Unarchive a previously archived space.",
+    inputSchema: {
+      name: exports_external.string().describe("Space name to unarchive")
+    }
+  }, async ({ name }) => {
+    try {
+      const sp = unarchiveSpace(name);
+      return {
+        content: [{ type: "text", text: JSON.stringify(sp, null, 2) }]
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("create_project", {
+    title: "Create Project",
+    description: "Create a new project. Projects organize spaces and provide context for agent collaboration.",
+    inputSchema: {
+      name: exports_external.string().describe("Project name (unique)"),
+      description: exports_external.string().optional().describe("Project description"),
+      path: exports_external.string().optional().describe("Absolute path to project on disk"),
+      repository: exports_external.string().optional().describe("Repository URL"),
+      tags: exports_external.string().optional().describe(`JSON array of tags (e.g. '["backend", "api"]')`),
+      metadata: exports_external.string().optional().describe("JSON metadata string"),
+      settings: exports_external.string().optional().describe("JSON settings string")
+    }
+  }, async ({ name, description, path, repository, tags, metadata, settings }) => {
+    const agent = resolveIdentity();
+    let parsedTags;
+    if (tags) {
+      try {
+        parsedTags = JSON.parse(tags);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Invalid tags JSON. Expected array of strings." }],
+          isError: true
+        };
+      }
+    }
+    let parsedMetadata;
+    if (metadata) {
+      try {
+        parsedMetadata = JSON.parse(metadata);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Invalid metadata JSON." }],
+          isError: true
+        };
+      }
+    }
+    let parsedSettings;
+    if (settings) {
+      try {
+        parsedSettings = JSON.parse(settings);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Invalid settings JSON." }],
+          isError: true
+        };
+      }
+    }
+    try {
+      const project = createProject({
+        name,
+        created_by: agent,
+        description,
+        path,
+        repository,
+        tags: parsedTags,
+        metadata: parsedMetadata,
+        settings: parsedSettings
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(project, null, 2) }]
+      };
+    } catch (e) {
+      if (e.message?.includes("UNIQUE constraint")) {
+        return {
+          content: [{ type: "text", text: `Project "${name}" already exists` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("list_projects", {
+    title: "List Projects",
+    description: "List all registered projects.",
+    inputSchema: {
+      status: exports_external.enum(["active", "archived"]).optional().describe("Filter by project status")
+    }
+  }, async ({ status }) => {
+    const projects = listProjects(status ? { status } : undefined);
+    return {
+      content: [{ type: "text", text: JSON.stringify(projects, null, 2) }]
+    };
+  });
+  server.registerTool("get_project", {
+    title: "Get Project",
+    description: "Get full details of a project by ID or name.",
+    inputSchema: {
+      id: exports_external.string().describe("Project ID (UUID) or name")
+    }
+  }, async ({ id }) => {
+    let project = getProject(id);
+    if (!project) {
+      project = getProjectByName(id);
+    }
+    if (!project) {
+      return {
+        content: [{ type: "text", text: `Project "${id}" not found` }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(project, null, 2) }]
+    };
+  });
+  server.registerTool("update_project", {
+    title: "Update Project",
+    description: "Update a project's fields.",
+    inputSchema: {
+      id: exports_external.string().describe("Project ID (UUID)"),
+      name: exports_external.string().optional().describe("New project name"),
+      description: exports_external.string().optional().describe("New description"),
+      path: exports_external.string().optional().describe("New path"),
+      status: exports_external.enum(["active", "archived"]).optional().describe("New status"),
+      repository: exports_external.string().optional().describe("New repository URL"),
+      tags: exports_external.string().optional().describe("JSON array of tags"),
+      metadata: exports_external.string().optional().describe("JSON metadata string"),
+      settings: exports_external.string().optional().describe("JSON settings string")
+    }
+  }, async ({ id, name, description, path, status, repository, tags, metadata, settings }) => {
+    const updates = {};
+    if (name !== undefined)
+      updates.name = name;
+    if (description !== undefined)
+      updates.description = description;
+    if (path !== undefined)
+      updates.path = path;
+    if (status !== undefined)
+      updates.status = status;
+    if (repository !== undefined)
+      updates.repository = repository;
+    if (tags) {
+      try {
+        updates.tags = JSON.parse(tags);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Invalid tags JSON." }],
+          isError: true
+        };
+      }
+    }
+    if (metadata) {
+      try {
+        updates.metadata = JSON.parse(metadata);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Invalid metadata JSON." }],
+          isError: true
+        };
+      }
+    }
+    if (settings) {
+      try {
+        updates.settings = JSON.parse(settings);
+      } catch {
+        return {
+          content: [{ type: "text", text: "Invalid settings JSON." }],
+          isError: true
+        };
+      }
+    }
+    try {
+      const project = updateProject(id, updates);
+      return {
+        content: [{ type: "text", text: JSON.stringify(project, null, 2) }]
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("delete_project", {
+    title: "Delete Project",
+    description: "Delete a project permanently. Fails if spaces still reference it.",
+    inputSchema: {
+      id: exports_external.string().describe("Project ID (UUID)")
+    }
+  }, async ({ id }) => {
+    try {
+      const deleted = deleteProject(id);
+      if (!deleted) {
+        return {
+          content: [{ type: "text", text: `Project "${id}" not found` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify({ id, deleted: true }, null, 2) }]
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: e.message }],
+        isError: true
+      };
+    }
+  });
+  server.registerTool("delete_message", {
+    title: "Delete Message",
+    description: "Delete a message. Only the sender can delete their own messages. The agent is auto-resolved.",
+    inputSchema: {
+      id: exports_external.number().describe("Message ID to delete")
+    }
+  }, async ({ id }) => {
+    const agent = resolveIdentity();
+    const deleted = deleteMessage(id, agent);
+    if (!deleted) {
+      return {
+        content: [{ type: "text", text: `Message #${id} not found or not your message` }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ deleted: true }, null, 2) }]
+    };
+  });
+  server.registerTool("edit_message", {
+    title: "Edit Message",
+    description: "Edit a message's content. Only the sender can edit their own messages. The agent is auto-resolved.",
+    inputSchema: {
+      id: exports_external.number().describe("Message ID to edit"),
+      content: exports_external.string().describe("New message content")
+    }
+  }, async ({ id, content }) => {
+    const agent = resolveIdentity();
+    const msg = editMessage(id, agent, content);
+    if (!msg) {
+      return {
+        content: [{ type: "text", text: `Message #${id} not found or not your message` }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(msg, null, 2) }]
+    };
+  });
+  server.registerTool("pin_message", {
+    title: "Pin Message",
+    description: "Pin a message. Pinned messages can be retrieved with get_pinned_messages.",
+    inputSchema: {
+      id: exports_external.number().describe("Message ID to pin")
+    }
+  }, async ({ id }) => {
+    const msg = pinMessage(id);
+    if (!msg) {
+      return {
+        content: [{ type: "text", text: `Message #${id} not found` }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(msg, null, 2) }]
+    };
+  });
+  server.registerTool("unpin_message", {
+    title: "Unpin Message",
+    description: "Unpin a previously pinned message.",
+    inputSchema: {
+      id: exports_external.number().describe("Message ID to unpin")
+    }
+  }, async ({ id }) => {
+    const msg = unpinMessage(id);
+    if (!msg) {
+      return {
+        content: [{ type: "text", text: `Message #${id} not found` }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(msg, null, 2) }]
+    };
+  });
+  server.registerTool("get_pinned_messages", {
+    title: "Get Pinned Messages",
+    description: "Retrieve pinned messages, optionally filtered by space or session.",
+    inputSchema: {
+      space: exports_external.string().optional().describe("Filter by space name"),
+      session_id: exports_external.string().optional().describe("Filter by session ID"),
+      limit: exports_external.number().optional().describe("Max messages to return")
+    }
+  }, async ({ space, session_id, limit }) => {
+    const messages = getPinnedMessages({ space, session_id, limit });
+    return {
+      content: [{ type: "text", text: JSON.stringify(messages, null, 2) }]
+    };
+  });
+  server.registerTool("heartbeat", {
+    title: "Heartbeat",
+    description: "Send a heartbeat to indicate agent is alive. Auto-resolves agent from CONVERSATIONS_AGENT_ID env var. Optionally set a status.",
+    inputSchema: {
+      status: exports_external.string().optional().describe("Agent status (e.g. 'online', 'busy', 'idle'). Defaults to 'online'.")
+    }
+  }, async ({ status }) => {
+    const agent = resolveIdentity();
+    heartbeat(agent, status);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ agent, status: status || "online", heartbeat: true }, null, 2) }]
+    };
+  });
+  server.registerTool("list_agents", {
+    title: "List Agents",
+    description: "List all agents with their presence status. Returns agent name, status, last seen time, and whether they are online.",
+    inputSchema: {
+      online_only: exports_external.boolean().optional().describe("Only return agents that are currently online (seen within last 60 seconds)")
+    }
+  }, async ({ online_only }) => {
+    const agents = listAgents({ online_only });
+    return {
+      content: [{ type: "text", text: JSON.stringify(agents, null, 2) }]
+    };
+  });
+  isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("mcp.js") || process.argv[1]?.endsWith("mcp.ts");
+  if (isDirectRun) {
+    startMcpServer().catch((error48) => {
+      console.error("MCP server error:", error48);
+      process.exit(1);
+    });
+  }
+});
+
+// src/server/serve.ts
+var exports_serve = {};
+__export(exports_serve, {
+  startDashboardServer: () => startDashboardServer
 });
-import { join as join2 } from "path";
+import { join as join2, resolve, sep } from "path";
 import { existsSync } from "fs";
+function securityHeaders(base) {
+  const headers = new Headers(base);
+  if (!headers.has("X-Content-Type-Options"))
+    headers.set("X-Content-Type-Options", "nosniff");
+  if (!headers.has("X-Frame-Options"))
+    headers.set("X-Frame-Options", "DENY");
+  if (!headers.has("Referrer-Policy"))
+    headers.set("Referrer-Policy", "no-referrer");
+  if (!headers.has("Permissions-Policy")) {
+    headers.set("Permissions-Policy", "camera=(), microphone=(), geolocation=()");
+  }
+  if (!headers.has("Cross-Origin-Resource-Policy")) {
+    headers.set("Cross-Origin-Resource-Policy", "same-origin");
+  }
+  if (!headers.has("Content-Security-Policy")) {
+    headers.set("Content-Security-Policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'; base-uri 'self'; frame-ancestors 'none'; object-src 'none'");
+  }
+  return headers;
+}
 function jsonResponse(data, status = 200) {
   return new Response(JSON.stringify(data), {
     status,
-    headers: { "Content-Type": "application/json" }
+    headers: securityHeaders({
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-store"
+    })
   });
 }
 function getStatus() {
@@ -31245,20 +32365,46 @@ function getStatus() {
   const totalMessages = db2.prepare("SELECT COUNT(*) as count FROM messages").get().count;
   const totalSessions = db2.prepare("SELECT COUNT(DISTINCT session_id) as count FROM messages").get().count;
   const totalUnread = db2.prepare("SELECT COUNT(*) as count FROM messages WHERE read_at IS NULL").get().count;
-  const totalChannels = db2.prepare("SELECT COUNT(*) as count FROM channels").get().count;
+  const totalSpaces = db2.prepare("SELECT COUNT(*) as count FROM spaces").get().count;
+  const totalProjects = db2.prepare("SELECT COUNT(*) as count FROM projects").get().count;
   return {
     db_path: dbPath,
     total_messages: totalMessages,
     total_sessions: totalSessions,
-    total_channels: totalChannels,
+    total_spaces: totalSpaces,
+    total_projects: totalProjects,
     unread_messages: totalUnread
   };
 }
-function startDashboardServer(port = 3456) {
+function normalizeHost(value) {
+  const host = typeof value === "string" ? value.trim() : "";
+  return host.length > 0 ? host : "127.0.0.1";
+}
+function normalizePort(value, fallback) {
+  const parsed = typeof value === "string" ? parseInt(value, 10) : value;
+  if (!Number.isFinite(parsed))
+    return fallback;
+  const port = parsed;
+  if (port < 0 || port > 65535)
+    return fallback;
+  return port;
+}
+function isSameOrigin(req) {
+  const origin = req.headers.get("origin");
+  if (!origin)
+    return true;
+  if (origin === "null")
+    return false;
+  return origin === new URL(req.url).origin;
+}
+function startDashboardServer(port = 3456, host) {
+  const resolvedPort = normalizePort(port, 3456);
+  const resolvedHost = normalizeHost(host ?? process.env.CONVERSATIONS_DASHBOARD_HOST);
   const dashboardDist = join2(import.meta.dir, "../../dashboard/dist");
   const hasDist = existsSync(dashboardDist);
   const server2 = Bun.serve({
-    port,
+    port: resolvedPort,
+    hostname: resolvedHost,
     async fetch(req) {
       const url2 = new URL(req.url);
       const path = url2.pathname;
@@ -31266,57 +32412,390 @@ function startDashboardServer(port = 3456) {
         return jsonResponse(getStatus());
       }
       if (path === "/api/messages" && req.method === "GET") {
-        const limit = parseInt(url2.searchParams.get("limit") || "50");
+        const rawLimit = url2.searchParams.get("limit");
+        let limit = parseInt(rawLimit || "50", 10);
+        if (!Number.isFinite(limit) || limit <= 0)
+          limit = 50;
+        if (limit > 500)
+          limit = 500;
         const session = url2.searchParams.get("session") || undefined;
-        const channel = url2.searchParams.get("channel") || undefined;
+        const space = url2.searchParams.get("space") || undefined;
         const from = url2.searchParams.get("from") || undefined;
         const to = url2.searchParams.get("to") || undefined;
-        const messages = readMessages({ session_id: session, channel, from, to, limit });
-        return jsonResponse(messages.reverse());
+        const messages = readMessages({ session_id: session, space, from, to, limit, order: "desc" });
+        return jsonResponse(messages);
       }
       if (path === "/api/messages" && req.method === "POST") {
+        if (!isSameOrigin(req)) {
+          return jsonResponse({ error: "Invalid origin" }, 403);
+        }
         try {
           const text = await req.text();
           const body = JSON.parse(text);
+          const from = typeof body.from === "string" ? body.from.trim() : "";
+          const to = typeof body.to === "string" ? body.to.trim() : "";
+          const content = typeof body.content === "string" ? body.content.trim() : "";
+          const space = typeof body.space === "string" ? body.space.trim() : undefined;
+          const priority = typeof body.priority === "string" ? body.priority.trim().toLowerCase() : undefined;
+          if (!from || !to || !content) {
+            return jsonResponse({ error: "from, to, and content are required" }, 400);
+          }
+          if (priority && !["low", "normal", "high", "urgent"].includes(priority)) {
+            return jsonResponse({ error: "Invalid priority" }, 400);
+          }
           const msg = sendMessage({
-            from: body.from,
-            to: body.to,
-            content: body.content,
-            channel: body.channel,
-            priority: body.priority
+            from,
+            to,
+            content,
+            space,
+            priority
           });
           return jsonResponse(msg);
         } catch (e) {
           return jsonResponse({ error: e.message }, 400);
         }
       }
+      if (path === "/api/messages/search" && req.method === "GET") {
+        const q = url2.searchParams.get("q") || "";
+        if (!q.trim()) {
+          return jsonResponse({ error: "Query parameter 'q' is required" }, 400);
+        }
+        const rawLimit = url2.searchParams.get("limit");
+        let limit = parseInt(rawLimit || "50", 10);
+        if (!Number.isFinite(limit) || limit <= 0)
+          limit = 50;
+        if (limit > 500)
+          limit = 500;
+        const space = url2.searchParams.get("space") || undefined;
+        const from = url2.searchParams.get("from") || undefined;
+        const to = url2.searchParams.get("to") || undefined;
+        const messages = searchMessages({ query: q.trim(), space, from, to, limit });
+        return jsonResponse(messages);
+      }
+      if (path === "/api/export" && req.method === "GET") {
+        const space = url2.searchParams.get("space") || undefined;
+        const session = url2.searchParams.get("session") || undefined;
+        const from = url2.searchParams.get("from") || undefined;
+        const since = url2.searchParams.get("since") || undefined;
+        const until = url2.searchParams.get("until") || undefined;
+        const format = url2.searchParams.get("format") === "csv" ? "csv" : "json";
+        const result = exportMessages({ space, session_id: session, from, since, until, format });
+        if (format === "csv") {
+          return new Response(result, {
+            status: 200,
+            headers: securityHeaders({
+              "Content-Type": "text/csv; charset=utf-8",
+              "Content-Disposition": 'attachment; filename="messages.csv"',
+              "Cache-Control": "no-store"
+            })
+          });
+        }
+        return jsonResponse(JSON.parse(result));
+      }
+      if (path === "/api/messages/pinned" && req.method === "GET") {
+        const space = url2.searchParams.get("space") || undefined;
+        const session_id = url2.searchParams.get("session_id") || undefined;
+        const rawLimit = url2.searchParams.get("limit");
+        let limit;
+        if (rawLimit) {
+          limit = parseInt(rawLimit, 10);
+          if (!Number.isFinite(limit) || limit <= 0)
+            limit = 50;
+          if (limit > 500)
+            limit = 500;
+        }
+        const messages = getPinnedMessages({ space, session_id, limit });
+        return jsonResponse(messages);
+      }
+      const pinMatch = path.match(/^\/api\/messages\/(\d+)\/pin$/);
+      if (pinMatch) {
+        const messageId = parseInt(pinMatch[1], 10);
+        if (req.method === "POST") {
+          if (!isSameOrigin(req)) {
+            return jsonResponse({ error: "Invalid origin" }, 403);
+          }
+          const msg = pinMessage(messageId);
+          if (!msg)
+            return jsonResponse({ error: "Message not found" }, 404);
+          return jsonResponse(msg);
+        }
+        if (req.method === "DELETE") {
+          if (!isSameOrigin(req)) {
+            return jsonResponse({ error: "Invalid origin" }, 403);
+          }
+          const msg = unpinMessage(messageId);
+          if (!msg)
+            return jsonResponse({ error: "Message not found" }, 404);
+          return jsonResponse(msg);
+        }
+      }
+      const messageMatch = path.match(/^\/api\/messages\/(\d+)$/);
+      if (messageMatch) {
+        const messageId = parseInt(messageMatch[1], 10);
+        if (req.method === "DELETE") {
+          if (!isSameOrigin(req)) {
+            return jsonResponse({ error: "Invalid origin" }, 403);
+          }
+          const from = url2.searchParams.get("from") || "";
+          if (!from) {
+            return jsonResponse({ error: "'from' query parameter is required" }, 400);
+          }
+          const deleted = deleteMessage(messageId, from);
+          if (!deleted)
+            return jsonResponse({ error: "Message not found or not your message" }, 404);
+          return jsonResponse({ id: messageId, deleted: true });
+        }
+        if (req.method === "PUT") {
+          if (!isSameOrigin(req)) {
+            return jsonResponse({ error: "Invalid origin" }, 403);
+          }
+          try {
+            const text = await req.text();
+            const body = JSON.parse(text);
+            const content = typeof body.content === "string" ? body.content.trim() : "";
+            const from = typeof body.from === "string" ? body.from.trim() : "";
+            if (!content || !from) {
+              return jsonResponse({ error: "content and from are required" }, 400);
+            }
+            const msg = editMessage(messageId, from, content);
+            if (!msg)
+              return jsonResponse({ error: "Message not found or not your message" }, 404);
+            return jsonResponse(msg);
+          } catch (e) {
+            return jsonResponse({ error: e.message }, 400);
+          }
+        }
+      }
       if (path === "/api/sessions") {
         const agent = url2.searchParams.get("agent") || undefined;
         return jsonResponse(listSessions(agent));
       }
-      if (path === "/api/channels" && req.method === "GET") {
-        return jsonResponse(listChannels());
+      if (path === "/api/spaces" && req.method === "GET") {
+        const projectId = url2.searchParams.get("project_id") || undefined;
+        const includeArchived = url2.searchParams.get("include_archived") === "true";
+        const listOpts = {};
+        if (projectId)
+          listOpts.project_id = projectId;
+        if (includeArchived)
+          listOpts.include_archived = true;
+        return jsonResponse(listSpaces(Object.keys(listOpts).length > 0 ? listOpts : undefined));
+      }
+      if (path === "/api/spaces" && req.method === "POST") {
+        if (!isSameOrigin(req)) {
+          return jsonResponse({ error: "Invalid origin" }, 403);
+        }
+        try {
+          const text = await req.text();
+          const body = JSON.parse(text);
+          const name = typeof body.name === "string" ? body.name.trim() : "";
+          const createdBy = typeof body.created_by === "string" ? body.created_by.trim() : "";
+          const description = typeof body.description === "string" ? body.description.trim() : undefined;
+          const parent_id = typeof body.parent_id === "string" ? body.parent_id.trim() : undefined;
+          const project_id = typeof body.project_id === "string" ? body.project_id.trim() : undefined;
+          if (!name || !createdBy) {
+            return jsonResponse({ error: "name and created_by are required" }, 400);
+          }
+          const sp = createSpace(name, createdBy, { description, parent_id, project_id });
+          return jsonResponse(sp);
+        } catch (e) {
+          return jsonResponse({ error: e.message }, 400);
+        }
+      }
+      const spaceArchiveMatch = path.match(/^\/api\/spaces\/([^/]+)\/archive$/);
+      if (spaceArchiveMatch && req.method === "POST") {
+        if (!isSameOrigin(req)) {
+          return jsonResponse({ error: "Invalid origin" }, 403);
+        }
+        try {
+          const sp = archiveSpace(decodeURIComponent(spaceArchiveMatch[1]));
+          return jsonResponse(sp);
+        } catch (e) {
+          return jsonResponse({ error: e.message }, 400);
+        }
+      }
+      const spaceUnarchiveMatch = path.match(/^\/api\/spaces\/([^/]+)\/unarchive$/);
+      if (spaceUnarchiveMatch && req.method === "POST") {
+        if (!isSameOrigin(req)) {
+          return jsonResponse({ error: "Invalid origin" }, 403);
+        }
+        try {
+          const sp = unarchiveSpace(decodeURIComponent(spaceUnarchiveMatch[1]));
+          return jsonResponse(sp);
+        } catch (e) {
+          return jsonResponse({ error: e.message }, 400);
+        }
+      }
+      const spaceMatch = path.match(/^\/api\/spaces\/([^/]+)$/);
+      if (spaceMatch) {
+        const spaceName = decodeURIComponent(spaceMatch[1]);
+        if (req.method === "GET") {
+          const sp = getSpace(spaceName);
+          if (!sp)
+            return jsonResponse({ error: "Space not found" }, 404);
+          return jsonResponse(sp);
+        }
+        if (req.method === "PUT") {
+          if (!isSameOrigin(req)) {
+            return jsonResponse({ error: "Invalid origin" }, 403);
+          }
+          try {
+            const text = await req.text();
+            const body = JSON.parse(text);
+            const updates = {};
+            if (body.description !== undefined)
+              updates.description = body.description;
+            if (body.parent_id !== undefined)
+              updates.parent_id = body.parent_id;
+            if (body.project_id !== undefined)
+              updates.project_id = body.project_id;
+            const sp = updateSpace(spaceName, updates);
+            return jsonResponse(sp);
+          } catch (e) {
+            return jsonResponse({ error: e.message }, 400);
+          }
+        }
+      }
+      if (path === "/api/projects" && req.method === "GET") {
+        const status = url2.searchParams.get("status");
+        return jsonResponse(listProjects(status ? { status } : undefined));
       }
-      if (path === "/api/channels" && req.method === "POST") {
+      if (path === "/api/projects" && req.method === "POST") {
+        if (!isSameOrigin(req)) {
+          return jsonResponse({ error: "Invalid origin" }, 403);
+        }
         try {
           const text = await req.text();
           const body = JSON.parse(text);
-          const ch = createChannel(body.name, body.created_by, body.description);
-          return jsonResponse(ch);
+          const name = typeof body.name === "string" ? body.name.trim() : "";
+          const createdBy = typeof body.created_by === "string" ? body.created_by.trim() : "";
+          if (!name || !createdBy) {
+            return jsonResponse({ error: "name and created_by are required" }, 400);
+          }
+          const project = createProject({
+            name,
+            created_by: createdBy,
+            description: body.description,
+            path: body.path,
+            repository: body.repository,
+            tags: body.tags,
+            metadata: body.metadata,
+            settings: body.settings
+          });
+          return jsonResponse(project);
         } catch (e) {
           return jsonResponse({ error: e.message }, 400);
         }
       }
+      const projectMatch = path.match(/^\/api\/projects\/([^/]+)$/);
+      if (projectMatch) {
+        const projectId = projectMatch[1];
+        if (req.method === "GET") {
+          let project = getProject(projectId);
+          if (!project)
+            project = getProjectByName(projectId);
+          if (!project)
+            return jsonResponse({ error: "Project not found" }, 404);
+          return jsonResponse(project);
+        }
+        if (req.method === "PUT") {
+          if (!isSameOrigin(req)) {
+            return jsonResponse({ error: "Invalid origin" }, 403);
+          }
+          try {
+            const text = await req.text();
+            const body = JSON.parse(text);
+            const project = updateProject(projectId, body);
+            return jsonResponse(project);
+          } catch (e) {
+            return jsonResponse({ error: e.message }, 400);
+          }
+        }
+        if (req.method === "DELETE") {
+          if (!isSameOrigin(req)) {
+            return jsonResponse({ error: "Invalid origin" }, 403);
+          }
+          try {
+            const deleted = deleteProject(projectId);
+            if (!deleted)
+              return jsonResponse({ error: "Project not found" }, 404);
+            return jsonResponse({ id: projectId, deleted: true });
+          } catch (e) {
+            return jsonResponse({ error: e.message }, 400);
+          }
+        }
+      }
+      if (path === "/api/agents" && req.method === "GET") {
+        const onlineOnly = url2.searchParams.get("online_only") === "true";
+        const agents = listAgents({ online_only: onlineOnly });
+        return jsonResponse(agents);
+      }
+      if (path === "/api/version" && req.method === "GET") {
+        try {
+          const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+          const current = pkg.version;
+          const res = await fetch("https://registry.npmjs.org/@hasna/conversations/latest");
+          const data = await res.json();
+          const latest = data.version;
+          return jsonResponse({ current, latest, updateAvailable: current !== latest });
+        } catch (e) {
+          return jsonResponse({ error: e.message }, 500);
+        }
+      }
+      if (path === "/api/update" && req.method === "POST") {
+        if (!isSameOrigin(req)) {
+          return jsonResponse({ error: "Invalid origin" }, 403);
+        }
+        try {
+          const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+          const current = pkg.version;
+          const res = await fetch("https://registry.npmjs.org/@hasna/conversations/latest");
+          const data = await res.json();
+          const latest = data.version;
+          if (current === latest) {
+            return jsonResponse({ current, latest, status: "up-to-date" });
+          }
+          const proc = Bun.spawn(["bun", "install", "-g", `@hasna/conversations@${latest}`], {
+            stdout: "pipe",
+            stderr: "pipe"
+          });
+          const exitCode = await proc.exited;
+          const stdout = await new Response(proc.stdout).text();
+          const stderr = await new Response(proc.stderr).text();
+          if (exitCode === 0) {
+            return jsonResponse({ current, latest, status: "updated", stdout });
+          } else {
+            return jsonResponse({ current, latest, status: "failed", exitCode, stderr }, 500);
+          }
+        } catch (e) {
+          return jsonResponse({ error: e.message }, 500);
+        }
+      }
       if (hasDist) {
-        let filePath = join2(dashboardDist, path === "/" ? "index.html" : path);
+        const baseDir = resolve(dashboardDist);
+        const safePath = path === "/" ? "index.html" : path.replace(/^\/+/, "");
+        const filePath = resolve(baseDir, safePath);
+        if (!filePath.startsWith(baseDir + sep)) {
+          return new Response("Not Found", { status: 404 });
+        }
         let file2 = Bun.file(filePath);
-        if (await file2.exists())
-          return new Response(file2);
+        if (await file2.exists()) {
+          const headers = securityHeaders();
+          if (file2.type)
+            headers.set("Content-Type", file2.type);
+          return new Response(file2, { headers });
+        }
         file2 = Bun.file(join2(dashboardDist, "index.html"));
-        if (await file2.exists())
-          return new Response(file2);
+        if (await file2.exists()) {
+          const headers = securityHeaders();
+          if (file2.type)
+            headers.set("Content-Type", file2.type);
+          return new Response(file2, { headers });
+        }
       }
-      return new Response("Not Found", { status: 404 });
+      return new Response("Not Found", {
+        status: 404,
+        headers: securityHeaders({ "Content-Type": "text/plain; charset=utf-8" })
+      });
     }
   });
   console.log(`Dashboard running at http://localhost:${server2.port}`);
@@ -31326,11 +32805,13 @@ var isDirectRun2;
 var init_serve = __esm(() => {
   init_messages();
   init_sessions();
-  init_channels();
+  init_spaces();
+  init_projects();
   init_db();
+  init_presence();
   isDirectRun2 = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("serve.ts") || process.argv[1]?.endsWith("serve.js");
   if (isDirectRun2) {
-    const port = parseInt(process.env.PORT || "3456");
+    const port = normalizePort(process.env.PORT, 3456);
     startDashboardServer(port);
   }
 });
@@ -31354,8 +32835,10 @@ var {
 // src/cli/index.tsx
 init_messages();
 init_sessions();
-init_channels();
+init_spaces();
+init_projects();
 init_db();
+init_presence();
 import chalk2 from "chalk";
 import { render } from "ink";
 import React8 from "react";
@@ -31865,15 +33348,21 @@ function SelectInput({ items = [], isFocused = true, initialIndex = 0, indicator
 var SelectInput_default = SelectInput;
 // src/cli/components/SessionList.tsx
 init_sessions();
-init_channels();
+init_spaces();
+init_db();
 import { jsxDEV } from "react/jsx-dev-runtime";
-function SessionList({ agent, onSelect, onSelectChannel, onNew }) {
+function getSpaceUnreadCount(spaceName, agent) {
+  const db2 = getDb();
+  const row = db2.prepare("SELECT COUNT(*) as count FROM messages WHERE space = ? AND from_agent != ? AND read_at IS NULL").get(spaceName, agent);
+  return row.count;
+}
+function SessionList({ agent, onSelect, onSelectSpace, onNew }) {
   const [sessions, setSessions] = useState3(() => listSessions(agent));
-  const [channels, setChannels] = useState3(() => listChannels());
+  const [spaces, setSpaces] = useState3(() => listSpaces());
   useEffect3(() => {
     const timer = setInterval(() => {
       setSessions(listSessions(agent));
-      setChannels(listChannels());
+      setSpaces(listSpaces());
     }, 1000);
     return () => clearInterval(timer);
   }, [agent]);
@@ -31881,11 +33370,36 @@ function SessionList({ agent, onSelect, onSelectChannel, onNew }) {
     if (input === "n")
       onNew();
   });
-  const channelItems = channels.map((ch) => ({
-    label: `#${ch.name}${ch.description ? ` \u2014 ${ch.description}` : ""}  (${ch.message_count} msgs, ${ch.member_count} members)`,
-    value: `channel:${ch.name}`
-  }));
-  const dmSessions = sessions.filter((s) => !s.session_id.startsWith("channel:"));
+  const topLevel = spaces.filter((sp) => !sp.parent_id);
+  const children = spaces.filter((sp) => sp.parent_id);
+  const spaceItems = [];
+  for (const sp of topLevel) {
+    const unread = getSpaceUnreadCount(sp.name, agent);
+    const unreadBadge = unread > 0 ? ` (${unread} unread)` : "";
+    spaceItems.push({
+      label: `#${sp.name}${sp.description ? ` \u2014 ${sp.description}` : ""}  ${sp.message_count} msgs${unreadBadge}`,
+      value: `space:${sp.name}`
+    });
+    const directChildren = children.filter((c) => c.parent_id === sp.name);
+    for (const child of directChildren) {
+      const childUnread = getSpaceUnreadCount(child.name, agent);
+      const childBadge = childUnread > 0 ? ` (${childUnread} unread)` : "";
+      spaceItems.push({
+        label: `  \u2514 #${child.name}${child.description ? ` \u2014 ${child.description}` : ""}  ${child.message_count} msgs${childBadge}`,
+        value: `space:${child.name}`
+      });
+      const grandChildren = children.filter((gc) => gc.parent_id === child.name);
+      for (const gc of grandChildren) {
+        const gcUnread = getSpaceUnreadCount(gc.name, agent);
+        const gcBadge = gcUnread > 0 ? ` (${gcUnread} unread)` : "";
+        spaceItems.push({
+          label: `    \u2514 #${gc.name}${gc.description ? ` \u2014 ${gc.description}` : ""}  ${gc.message_count} msgs${gcBadge}`,
+          value: `space:${gc.name}`
+        });
+      }
+    }
+  }
+  const dmSessions = sessions.filter((s) => !s.session_id.startsWith("space:"));
   const sessionItems = dmSessions.map((s) => {
     const others = s.participants.filter((p) => p !== agent).join(", ") || agent;
     const unread = s.unread_count > 0 ? ` (${s.unread_count} unread)` : "";
@@ -31894,7 +33408,7 @@ function SessionList({ agent, onSelect, onSelectChannel, onNew }) {
       value: s.session_id
     };
   });
-  const allItems = [...channelItems, ...sessionItems];
+  const allItems = [...spaceItems, ...sessionItems];
   if (allItems.length === 0) {
     return /* @__PURE__ */ jsxDEV(Box3, {
       flexDirection: "column",
@@ -31972,8 +33486,8 @@ function SessionList({ agent, onSelect, onSelectChannel, onNew }) {
       /* @__PURE__ */ jsxDEV(SelectInput_default, {
         items: allItems,
         onSelect: (item) => {
-          if (item.value.startsWith("channel:")) {
-            onSelectChannel(item.value.slice(8));
+          if (item.value.startsWith("space:")) {
+            onSelectSpace(item.value.slice(6));
           } else {
             const session = dmSessions.find((s) => s.session_id === item.value);
             if (session)
@@ -31986,31 +33500,55 @@ function SessionList({ agent, onSelect, onSelectChannel, onNew }) {
 }
 
 // src/cli/components/ChatView.tsx
-import { useState as useState5, useEffect as useEffect5 } from "react";
+import { useState as useState5, useEffect as useEffect5, useRef as useRef2 } from "react";
 import { Box as Box5, Text as Text6, useInput as useInput4 } from "ink";
 init_messages();
 
 // src/lib/poll.ts
 init_messages();
-import { useState as useState4, useEffect as useEffect4, useRef as useRef2 } from "react";
+import { useState as useState4, useEffect as useEffect4 } from "react";
 function startPolling(opts) {
   const interval = opts.interval_ms ?? 200;
-  let lastSeen = new Date().toISOString();
   let stopped = false;
-  const poll = () => {
-    if (stopped)
-      return;
-    const messages = readMessages({
+  let inFlight = false;
+  let lastSeenId = 0;
+  const seedLastSeen = () => {
+    const latest = readMessages({
       session_id: opts.session_id,
       to: opts.to_agent,
-      channel: opts.channel,
-      since: lastSeen
+      space: opts.space,
+      order: "desc",
+      limit: 1
     });
-    if (messages.length > 0) {
-      lastSeen = messages[messages.length - 1].created_at;
-      opts.on_messages(messages);
+    if (latest.length > 0) {
+      lastSeenId = latest[0].id;
+    }
+  };
+  const poll = () => {
+    if (stopped || inFlight)
+      return;
+    inFlight = true;
+    try {
+      const messages = readMessages({
+        session_id: opts.session_id,
+        to: opts.to_agent,
+        space: opts.space,
+        since_id: lastSeenId,
+        order: "asc"
+      });
+      if (messages.length > 0) {
+        lastSeenId = messages[messages.length - 1].id;
+        try {
+          opts.on_messages(messages);
+        } catch (error) {
+          console.error("Polling callback error:", error);
+        }
+      }
+    } finally {
+      inFlight = false;
     }
   };
+  seedLastSeen();
   const timer = setInterval(poll, interval);
   return {
     stop: () => {
@@ -32059,38 +33597,51 @@ function MessageBubble({ message, isOwn }) {
 
 // src/cli/components/ChatView.tsx
 import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
-function ChatView({ agent, onBack, sessionId: initialSessionId, recipient, channelName }) {
+function ChatView({ agent, onBack, sessionId: initialSessionId, recipient, spaceName }) {
   const [messages, setMessages] = useState5([]);
   const [input, setInput] = useState5("");
   const [sessionId, setSessionId] = useState5(initialSessionId);
-  const isChannel = !!channelName;
+  const isSpace = !!spaceName;
+  const seenIds = useRef2(new Set);
   useEffect5(() => {
-    const opts = isChannel ? { channel: channelName } : sessionId ? { session_id: sessionId } : {};
-    if (isChannel || sessionId) {
+    seenIds.current = new Set;
+    const opts = isSpace ? { space: spaceName } : sessionId ? { session_id: sessionId } : {};
+    if (isSpace || sessionId) {
       const existing = readMessages(opts);
+      for (const msg of existing) {
+        seenIds.current.add(msg.id);
+      }
       setMessages(existing);
+    } else {
+      setMessages([]);
     }
-    const pollOpts = isChannel ? { channel: channelName } : sessionId ? { session_id: sessionId } : null;
+    const pollOpts = isSpace ? { space: spaceName } : sessionId ? { session_id: sessionId } : null;
     if (!pollOpts)
       return;
     const { stop } = startPolling({
       ...pollOpts,
       interval_ms: 200,
       on_messages: (newMsgs) => {
-        setMessages((prev) => [...prev, ...newMsgs]);
+        const unseen = newMsgs.filter((msg) => !seenIds.current.has(msg.id));
+        if (unseen.length === 0)
+          return;
+        for (const msg of unseen) {
+          seenIds.current.add(msg.id);
+        }
+        setMessages((prev) => [...prev, ...unseen]);
       }
     });
     return stop;
-  }, [sessionId, channelName]);
+  }, [sessionId, spaceName]);
   useEffect5(() => {
     if (messages.length === 0)
       return;
-    if (isChannel && channelName) {
-      markChannelRead(channelName, agent);
+    if (isSpace && spaceName) {
+      markSpaceRead(spaceName, agent);
     } else if (sessionId) {
       markSessionRead(sessionId, agent);
     }
-  }, [messages.length]);
+  }, [messages.length, isSpace, spaceName, sessionId, agent]);
   useInput4((_, key) => {
     if (key.escape)
       onBack();
@@ -32098,14 +33649,15 @@ function ChatView({ agent, onBack, sessionId: initialSessionId, recipient, chann
   const handleSubmit = (value) => {
     if (!value.trim())
       return;
-    if (isChannel && channelName) {
+    if (isSpace && spaceName) {
       const msg = sendMessage({
         from: agent,
-        to: channelName,
+        to: spaceName,
         content: value.trim(),
-        channel: channelName,
-        session_id: `channel:${channelName}`
+        space: spaceName,
+        session_id: `space:${spaceName}`
       });
+      seenIds.current.add(msg.id);
       setMessages((prev) => [...prev, msg]);
     } else {
       const to = recipient || agent;
@@ -32115,14 +33667,16 @@ function ChatView({ agent, onBack, sessionId: initialSessionId, recipient, chann
         content: value.trim(),
         session_id: sessionId
       });
+      seenIds.current.add(msg.id);
+      setMessages((prev) => [...prev, msg]);
       if (!sessionId) {
         setSessionId(msg.session_id);
       }
     }
     setInput("");
   };
-  const title = isChannel ? `#${channelName}` : recipient || "self";
-  const prompt = isChannel ? `${agent} \u2192 #${channelName}` : `${agent} \u2192 ${recipient || "self"}`;
+  const title = isSpace ? `#${spaceName}` : recipient || "self";
+  const prompt = isSpace ? `${agent} \u2192 #${spaceName}` : `${agent} \u2192 ${recipient || "self"}`;
   return /* @__PURE__ */ jsxDEV3(Box5, {
     flexDirection: "column",
     padding: 1,
@@ -32132,7 +33686,7 @@ function ChatView({ agent, onBack, sessionId: initialSessionId, recipient, chann
         children: [
           /* @__PURE__ */ jsxDEV3(Text6, {
             bold: true,
-            color: isChannel ? "magenta" : "cyan",
+            color: isSpace ? "magenta" : "cyan",
             children: title
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV3(Text6, {
@@ -32156,7 +33710,7 @@ function ChatView({ agent, onBack, sessionId: initialSessionId, recipient, chann
         marginTop: 1,
         children: [
           /* @__PURE__ */ jsxDEV3(Text6, {
-            color: isChannel ? "magenta" : "cyan",
+            color: isSpace ? "magenta" : "cyan",
             children: [
               prompt,
               ": "
@@ -32180,7 +33734,7 @@ function App({ agent }) {
   const { exit } = useApp();
   const [view, setView] = useState6("sessions");
   const [currentSession, setCurrentSession] = useState6(null);
-  const [currentChannel, setCurrentChannel] = useState6(null);
+  const [currentSpace, setCurrentSpace] = useState6(null);
   const [newTo, setNewTo] = useState6("");
   useInput5((input, key) => {
     if (input === "q" && view === "sessions") {
@@ -32195,9 +33749,9 @@ function App({ agent }) {
     setCurrentSession(session);
     setView("chat");
   };
-  const handleSelectChannel = (channelName) => {
-    setCurrentChannel(channelName);
-    setView("channel");
+  const handleSelectSpace = (spaceName) => {
+    setCurrentSpace(spaceName);
+    setView("space");
   };
   const handleNewConversation = () => {
     setView("new");
@@ -32217,7 +33771,7 @@ function App({ agent }) {
   };
   const handleBack = () => {
     setCurrentSession(null);
-    setCurrentChannel(null);
+    setCurrentSpace(null);
     setView("sessions");
   };
   if (view === "new") {
@@ -32251,10 +33805,10 @@ function App({ agent }) {
       ]
     }, undefined, true, undefined, this);
   }
-  if (view === "channel" && currentChannel) {
+  if (view === "space" && currentSpace) {
     return /* @__PURE__ */ jsxDEV4(ChatView, {
       agent,
-      channelName: currentChannel,
+      spaceName: currentSpace,
       onBack: handleBack
     }, undefined, false, undefined, this);
   }
@@ -32270,22 +33824,45 @@ function App({ agent }) {
   return /* @__PURE__ */ jsxDEV4(SessionList, {
     agent,
     onSelect: handleSelectSession,
-    onSelectChannel: handleSelectChannel,
+    onSelectSpace: handleSelectSpace,
     onNew: handleNewConversation
   }, undefined, false, undefined, this);
 }
 
 // src/cli/index.tsx
 var program2 = new Command;
-program2.name("conversations").description("Real-time CLI messaging for AI agents").version("0.0.8");
+program2.name("conversations").description("Real-time CLI messaging for AI agents").version("0.1.0");
 program2.command("send").description("Send a message to an agent").argument("<message>", "Message content").requiredOption("--to <agent>", "Recipient agent ID").option("--from <agent>", "Sender agent ID").option("--session <id>", "Session ID (auto-generated if omitted)").option("--priority <level>", "Priority: low, normal, high, urgent", "normal").option("--working-dir <path>", "Working directory context").option("--repository <repo>", "Repository context").option("--branch <branch>", "Branch context").option("--metadata <json>", "JSON metadata string").option("--json", "Output as JSON").action((message, opts) => {
-  const from = resolveIdentity(opts.from);
-  const metadata = opts.metadata ? JSON.parse(opts.metadata) : undefined;
+  const from = resolveIdentity(opts.from).trim();
+  const to = typeof opts.to === "string" ? opts.to.trim() : "";
+  const content = typeof message === "string" ? message : "";
+  const session = typeof opts.session === "string" && opts.session.trim() ? opts.session.trim() : undefined;
+  if (!from) {
+    console.error(chalk2.red("Sender identity is required."));
+    process.exit(1);
+  }
+  if (!to) {
+    console.error(chalk2.red("Recipient is required."));
+    process.exit(1);
+  }
+  if (!content.trim()) {
+    console.error(chalk2.red("Message content cannot be empty."));
+    process.exit(1);
+  }
+  let metadata;
+  if (opts.metadata) {
+    try {
+      metadata = JSON.parse(opts.metadata);
+    } catch {
+      console.error(chalk2.red("Invalid --metadata JSON."));
+      process.exit(1);
+    }
+  }
   const msg = sendMessage({
     from,
-    to: opts.to,
-    content: message,
-    session_id: opts.session,
+    to,
+    content,
+    session_id: session,
     priority: opts.priority,
     working_dir: opts.workingDir,
     repository: opts.repository,
@@ -32299,31 +33876,71 @@ program2.command("send").description("Send a message to an agent").argument("<me
   }
   closeDb();
 });
-program2.command("read").description("Read messages").option("--session <id>", "Filter by session ID").option("--from <agent>", "Filter by sender").option("--to <agent>", "Filter by recipient").option("--channel <name>", "Filter by channel").option("--since <timestamp>", "Messages after this ISO timestamp").option("--limit <n>", "Max messages to return", parseInt).option("--unread", "Only unread messages").option("--mark-read", "Mark returned messages as read").option("--json", "Output as JSON").action((opts) => {
+program2.command("read").description("Read messages").option("--session <id>", "Filter by session ID").option("--from <agent>", "Filter by sender").option("--to <agent>", "Filter by recipient").option("--space <name>", "Filter by space").option("--since <timestamp>", "Messages after this ISO timestamp").option("--limit <n>", "Max messages to return", parseInt).option("--unread", "Only unread messages").option("--mark-read", "Mark returned messages as read").option("--json", "Output as JSON").action((opts) => {
   const messages = readMessages({
     session_id: opts.session,
     from: opts.from,
     to: opts.to,
-    channel: opts.channel,
+    space: opts.space,
     since: opts.since,
     limit: opts.limit,
     unread_only: opts.unread
   });
-  if (opts.markRead && opts.to) {
-    const ids = messages.filter((m) => m.to_agent === opts.to && !m.read_at).map((m) => m.id);
-    if (ids.length > 0)
-      markRead(ids, opts.to);
+  if (opts.markRead) {
+    const reader = resolveIdentity(opts.to);
+    if (opts.space) {
+      markSpaceRead(opts.space, reader);
+    } else if (opts.session) {
+      markSessionRead(opts.session, reader);
+    } else {
+      const ids = messages.filter((m) => m.to_agent === reader && !m.read_at).map((m) => m.id);
+      if (ids.length > 0)
+        markRead(ids, reader);
+    }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(messages, null, 2));
+  } else {
+    if (messages.length === 0) {
+      console.log(chalk2.dim("No messages found."));
+    } else {
+      for (const msg of messages) {
+        const time3 = chalk2.dim(msg.created_at.slice(11, 19));
+        const from = chalk2.cyan(msg.from_agent);
+        const to = msg.space ? chalk2.magenta(`#${msg.space}`) : chalk2.yellow(msg.to_agent);
+        const priority = msg.priority !== "normal" ? chalk2.red(` [${msg.priority}]`) : "";
+        const unread = !msg.read_at ? chalk2.green(" *") : "";
+        console.log(`${time3} ${from} \u2192 ${to}${priority}${unread}: ${msg.content}`);
+      }
+    }
   }
+  closeDb();
+});
+program2.command("search").description("Search messages by content").argument("<query>", "Search query string").option("--space <name>", "Filter by space").option("--from <agent>", "Filter by sender").option("--to <agent>", "Filter by recipient").option("--limit <n>", "Max results to return", parseInt).option("--json", "Output as JSON").action((query, opts) => {
+  const q = typeof query === "string" ? query.trim() : "";
+  if (!q) {
+    console.error(chalk2.red("Search query cannot be empty."));
+    process.exit(1);
+  }
+  const messages = searchMessages({
+    query: q,
+    space: opts.space,
+    from: opts.from,
+    to: opts.to,
+    limit: opts.limit
+  });
   if (opts.json) {
     console.log(JSON.stringify(messages, null, 2));
   } else {
     if (messages.length === 0) {
       console.log(chalk2.dim("No messages found."));
     } else {
+      console.log(chalk2.dim(`Found ${messages.length} result(s) for "${q}":
+`));
       for (const msg of messages) {
         const time3 = chalk2.dim(msg.created_at.slice(11, 19));
         const from = chalk2.cyan(msg.from_agent);
-        const to = msg.channel ? chalk2.magenta(`#${msg.channel}`) : chalk2.yellow(msg.to_agent);
+        const to = msg.space ? chalk2.magenta(`#${msg.space}`) : chalk2.yellow(msg.to_agent);
         const priority = msg.priority !== "normal" ? chalk2.red(` [${msg.priority}]`) : "";
         const unread = !msg.read_at ? chalk2.green(" *") : "";
         console.log(`${time3} ${from} \u2192 ${to}${priority}${unread}: ${msg.content}`);
@@ -32355,13 +33972,25 @@ program2.command("reply").description("Reply to a message (uses same session)").
     console.error(chalk2.red(`Message #${opts.to} not found.`));
     process.exit(1);
   }
-  const from = resolveIdentity(opts.from);
+  const from = resolveIdentity(opts.from).trim();
+  const content = typeof message === "string" ? message : "";
+  if (!from) {
+    console.error(chalk2.red("Sender identity is required."));
+    process.exit(1);
+  }
+  if (!content.trim()) {
+    console.error(chalk2.red("Reply content cannot be empty."));
+    process.exit(1);
+  }
+  const space = original.space || (original.session_id?.startsWith("space:") ? original.session_id.slice(6) : undefined);
+  const to = space ? space : original.from_agent === from ? original.to_agent : original.from_agent;
   const msg = sendMessage({
     from,
-    to: original.from_agent,
-    content: message,
+    to,
+    content,
     session_id: original.session_id,
-    priority: opts.priority
+    priority: opts.priority,
+    space
   });
   if (opts.json) {
     console.log(JSON.stringify(msg, null, 2));
@@ -32370,17 +33999,19 @@ program2.command("reply").description("Reply to a message (uses same session)").
   }
   closeDb();
 });
-program2.command("mark-read").description("Mark messages as read").argument("[ids...]", "Message IDs to mark as read").option("--session <id>", "Mark all messages in session as read").option("--channel <name>", "Mark all messages in channel as read").option("--agent <id>", "Agent marking messages as read").option("--json", "Output as JSON").action((ids, opts) => {
+program2.command("mark-read").description("Mark messages as read").argument("[ids...]", "Message IDs to mark as read").option("--all", "Mark all messages as read").option("--session <id>", "Mark all messages in session as read").option("--space <name>", "Mark all messages in space as read").option("--agent <id>", "Agent marking messages as read").option("--json", "Output as JSON").action((ids, opts) => {
   const agent = resolveIdentity(opts.agent);
   let count = 0;
-  if (opts.session) {
+  if (opts.all) {
+    count = markAllRead(agent);
+  } else if (opts.session) {
     count = markSessionRead(opts.session, agent);
-  } else if (opts.channel) {
-    count = markChannelRead(opts.channel, agent);
+  } else if (opts.space) {
+    count = markSpaceRead(opts.space, agent);
   } else if (ids.length > 0) {
     count = markRead(ids.map(Number), agent);
   } else {
-    console.error(chalk2.red("Provide message IDs, --session, or --channel flag."));
+    console.error(chalk2.red("Provide message IDs, --all, --session, or --space flag."));
     process.exit(1);
   }
   if (opts.json) {
@@ -32390,18 +34021,33 @@ program2.command("mark-read").description("Mark messages as read").argument("[id
   }
   closeDb();
 });
+program2.command("export").description("Export messages as JSON or CSV").option("--space <name>", "Filter by space").option("--session <id>", "Filter by session ID").option("--from <agent>", "Filter by sender").option("--since <date>", "Messages after this ISO date").option("--until <date>", "Messages before this ISO date").option("--format <format>", "Output format: json or csv", "json").action((opts) => {
+  const format = opts.format === "csv" ? "csv" : "json";
+  const result = exportMessages({
+    space: opts.space,
+    session_id: opts.session,
+    from: opts.from,
+    since: opts.since,
+    until: opts.until,
+    format
+  });
+  console.log(result);
+  closeDb();
+});
 program2.command("status").description("Show database stats").option("--json", "Output as JSON").action((opts) => {
   const db2 = getDb();
   const dbPath = getDbPath();
   const totalMessages = db2.prepare("SELECT COUNT(*) as count FROM messages").get().count;
   const totalSessions = db2.prepare("SELECT COUNT(DISTINCT session_id) as count FROM messages").get().count;
   const totalUnread = db2.prepare("SELECT COUNT(*) as count FROM messages WHERE read_at IS NULL").get().count;
-  const totalChannels = db2.prepare("SELECT COUNT(*) as count FROM channels").get().count;
+  const totalSpaces = db2.prepare("SELECT COUNT(*) as count FROM spaces").get().count;
+  const totalProjects = db2.prepare("SELECT COUNT(*) as count FROM projects").get().count;
   const stats = {
     db_path: dbPath,
     total_messages: totalMessages,
     total_sessions: totalSessions,
-    total_channels: totalChannels,
+    total_spaces: totalSpaces,
+    total_projects: totalProjects,
     unread_messages: totalUnread
   };
   if (opts.json) {
@@ -32411,71 +34057,236 @@ program2.command("status").description("Show database stats").option("--json", "
     console.log(`  DB Path:    ${stats.db_path}`);
     console.log(`  Messages:   ${stats.total_messages}`);
     console.log(`  Sessions:   ${stats.total_sessions}`);
-    console.log(`  Channels:   ${stats.total_channels}`);
+    console.log(`  Spaces:     ${stats.total_spaces}`);
+    console.log(`  Projects:   ${stats.total_projects}`);
     console.log(`  Unread:     ${stats.unread_messages}`);
   }
   closeDb();
 });
-var channel = program2.command("channel").description("Manage channels");
-channel.command("create").description("Create a new channel").argument("<name>", "Channel name").option("--description <text>", "Channel description").option("--from <agent>", "Creator agent ID").option("--json", "Output as JSON").action((name, opts) => {
-  const agent = resolveIdentity(opts.from);
+program2.command("update").description("Check for and install updates").option("--check", "Only check for updates, don't install").option("--json", "Output as JSON").action(async (opts) => {
+  const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+  const current = pkg.version;
+  let latest;
+  try {
+    const res = await fetch("https://registry.npmjs.org/@hasna/conversations/latest");
+    const data = await res.json();
+    latest = data.version;
+  } catch {
+    if (opts.json) {
+      console.log(JSON.stringify({ error: "Failed to check npm registry" }));
+    } else {
+      console.error(chalk2.red("Failed to check npm registry for updates."));
+    }
+    process.exit(1);
+  }
+  const updateAvailable = current !== latest;
+  if (opts.check || !updateAvailable) {
+    if (opts.json) {
+      console.log(JSON.stringify({ current, latest, updateAvailable }));
+    } else if (updateAvailable) {
+      console.log(`Current version: ${chalk2.yellow(current)}`);
+      console.log(`Latest version:  ${chalk2.green(latest)}`);
+      console.log(chalk2.cyan(`Run ${chalk2.bold("conversations update")} to install.`));
+    } else {
+      console.log(chalk2.green(`Already on latest version (${current})`));
+    }
+    return;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ current, latest, updateAvailable, status: "updating" }));
+  } else {
+    console.log(`Updating from ${chalk2.yellow(current)} to ${chalk2.green(latest)}...`);
+  }
+  const proc = Bun.spawn(["bun", "install", "-g", `@hasna/conversations@${latest}`], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode === 0) {
+    if (!opts.json) {
+      console.log(chalk2.green(`
+Successfully updated to v${latest}`));
+    }
+  } else {
+    if (opts.json) {
+      console.log(JSON.stringify({ error: "Update failed", exitCode }));
+    } else {
+      console.error(chalk2.red(`
+Update failed (exit code ${exitCode})`));
+    }
+    process.exit(1);
+  }
+});
+var space = program2.command("space").description("Manage spaces");
+space.command("create").description("Create a new space").argument("<name>", "Space name").option("--description <text>", "Space description").option("--parent <name>", "Parent space name (for nesting)").option("--project <id>", "Project ID to associate with").option("--from <agent>", "Creator agent ID").option("--json", "Output as JSON").action((name, opts) => {
+  const agent = resolveIdentity(opts.from).trim();
+  const spaceName = typeof name === "string" ? name.trim() : "";
+  if (!agent) {
+    console.error(chalk2.red("Creator identity is required."));
+    process.exit(1);
+  }
+  if (!spaceName) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
   try {
-    const ch = createChannel(name, agent, opts.description);
+    const description = typeof opts.description === "string" && opts.description.trim() ? opts.description.trim() : undefined;
+    const sp = createSpace(spaceName, agent, {
+      description,
+      parent_id: opts.parent,
+      project_id: opts.project
+    });
     if (opts.json) {
-      console.log(JSON.stringify(ch, null, 2));
+      console.log(JSON.stringify(sp, null, 2));
     } else {
-      console.log(chalk2.green(`Channel #${ch.name} created`) + (ch.description ? chalk2.dim(` \u2014 ${ch.description}`) : ""));
+      console.log(chalk2.green(`Space #${sp.name} created`) + (sp.description ? chalk2.dim(` \u2014 ${sp.description}`) : ""));
     }
   } catch (e) {
     if (e.message?.includes("UNIQUE constraint")) {
-      console.error(chalk2.red(`Channel #${name} already exists.`));
+      console.error(chalk2.red(`Space #${spaceName} already exists.`));
       process.exit(1);
     }
-    throw e;
+    console.error(chalk2.red(e.message));
+    process.exit(1);
   }
   closeDb();
 });
-channel.command("list").description("List all channels").option("--json", "Output as JSON").action((opts) => {
-  const channels = listChannels();
+space.command("list").description("List all spaces").option("--project <id>", "Filter by project ID").option("--parent <name>", "Filter by parent space name").option("--top-level", "Show only top-level spaces").option("--archived", "Include archived spaces").option("--json", "Output as JSON").action((opts) => {
+  const listOpts = {};
+  if (opts.project)
+    listOpts.project_id = opts.project;
+  if (opts.topLevel) {
+    listOpts.parent_id = null;
+  } else if (opts.parent) {
+    listOpts.parent_id = opts.parent;
+  }
+  if (opts.archived)
+    listOpts.include_archived = true;
+  const spaces = listSpaces(listOpts);
   if (opts.json) {
-    console.log(JSON.stringify(channels, null, 2));
+    console.log(JSON.stringify(spaces, null, 2));
   } else {
-    if (channels.length === 0) {
-      console.log(chalk2.dim("No channels found."));
+    if (spaces.length === 0) {
+      console.log(chalk2.dim("No spaces found."));
     } else {
-      for (const ch of channels) {
-        const desc = ch.description ? chalk2.dim(` \u2014 ${ch.description}`) : "";
-        console.log(`${chalk2.magenta(`#${ch.name}`)}${desc}  ${ch.member_count} members, ${ch.message_count} messages`);
+      for (const sp of spaces) {
+        const desc = sp.description ? chalk2.dim(` \u2014 ${sp.description}`) : "";
+        const parent = sp.parent_id ? chalk2.dim(` (child of ${sp.parent_id})`) : "";
+        const archived = sp.archived_at ? chalk2.yellow(" [archived]") : "";
+        console.log(`${chalk2.magenta(`#${sp.name}`)}${desc}${parent}${archived}  ${sp.member_count} members, ${sp.message_count} messages`);
       }
     }
   }
   closeDb();
 });
-channel.command("send").description("Send a message to a channel").argument("<channel>", "Channel name").argument("<message>", "Message content").option("--from <agent>", "Sender agent ID").option("--priority <level>", "Priority: low, normal, high, urgent", "normal").option("--json", "Output as JSON").action((channelName, message, opts) => {
-  const from = resolveIdentity(opts.from);
-  const ch = getChannel(channelName);
-  if (!ch) {
-    console.error(chalk2.red(`Channel #${channelName} not found.`));
+space.command("update").description("Update a space").argument("<name>", "Space name").option("--description <text>", "New description").option("--parent <name>", "New parent space name").option("--project <id>", "New project ID").option("--json", "Output as JSON").action((name, opts) => {
+  const spaceName = typeof name === "string" ? name.trim() : "";
+  if (!spaceName) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
+  const updates = {};
+  if (opts.description !== undefined)
+    updates.description = opts.description;
+  if (opts.parent !== undefined)
+    updates.parent_id = opts.parent || null;
+  if (opts.project !== undefined)
+    updates.project_id = opts.project || null;
+  try {
+    const sp = updateSpace(spaceName, updates);
+    if (opts.json) {
+      console.log(JSON.stringify(sp, null, 2));
+    } else {
+      console.log(chalk2.green(`Space #${sp.name} updated.`));
+    }
+  } catch (e) {
+    console.error(chalk2.red(e.message));
+    process.exit(1);
+  }
+  closeDb();
+});
+space.command("archive").description("Archive a space").argument("<name>", "Space name").option("--json", "Output as JSON").action((name, opts) => {
+  const spaceName = typeof name === "string" ? name.trim() : "";
+  if (!spaceName) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
+  try {
+    const sp = archiveSpace(spaceName);
+    if (opts.json) {
+      console.log(JSON.stringify(sp, null, 2));
+    } else {
+      console.log(chalk2.green(`Space #${sp.name} archived.`));
+    }
+  } catch (e) {
+    console.error(chalk2.red(e.message));
+    process.exit(1);
+  }
+  closeDb();
+});
+space.command("unarchive").description("Unarchive a space").argument("<name>", "Space name").option("--json", "Output as JSON").action((name, opts) => {
+  const spaceName = typeof name === "string" ? name.trim() : "";
+  if (!spaceName) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
+  try {
+    const sp = unarchiveSpace(spaceName);
+    if (opts.json) {
+      console.log(JSON.stringify(sp, null, 2));
+    } else {
+      console.log(chalk2.green(`Space #${sp.name} unarchived.`));
+    }
+  } catch (e) {
+    console.error(chalk2.red(e.message));
+    process.exit(1);
+  }
+  closeDb();
+});
+space.command("send").description("Send a message to a space").argument("<space>", "Space name").argument("<message>", "Message content").option("--from <agent>", "Sender agent ID").option("--priority <level>", "Priority: low, normal, high, urgent", "normal").option("--json", "Output as JSON").action((spaceName, message, opts) => {
+  const from = resolveIdentity(opts.from).trim();
+  const spaceArg = typeof spaceName === "string" ? spaceName.trim() : "";
+  const content = typeof message === "string" ? message : "";
+  if (!from) {
+    console.error(chalk2.red("Sender identity is required."));
+    process.exit(1);
+  }
+  if (!spaceArg) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
+  if (!content.trim()) {
+    console.error(chalk2.red("Message content cannot be empty."));
+    process.exit(1);
+  }
+  const sp = getSpace(spaceArg);
+  if (!sp) {
+    console.error(chalk2.red(`Space #${spaceArg} not found.`));
     process.exit(1);
   }
   const msg = sendMessage({
     from,
-    to: channelName,
-    content: message,
-    channel: channelName,
-    session_id: `channel:${channelName}`,
+    to: spaceArg,
+    content,
+    space: spaceArg,
+    session_id: `space:${spaceArg}`,
     priority: opts.priority
   });
   if (opts.json) {
     console.log(JSON.stringify(msg, null, 2));
   } else {
-    console.log(chalk2.green(`Message sent to #${channelName}`) + chalk2.dim(` (id: ${msg.id})`));
+    console.log(chalk2.green(`Message sent to #${spaceArg}`) + chalk2.dim(` (id: ${msg.id})`));
   }
   closeDb();
 });
-channel.command("read").description("Read messages from a channel").argument("<channel>", "Channel name").option("--since <timestamp>", "Messages after this ISO timestamp").option("--limit <n>", "Max messages to return", parseInt).option("--json", "Output as JSON").action((channelName, opts) => {
+space.command("read").description("Read messages from a space").argument("<space>", "Space name").option("--since <timestamp>", "Messages after this ISO timestamp").option("--limit <n>", "Max messages to return", parseInt).option("--json", "Output as JSON").action((spaceName, opts) => {
+  const spaceArg = typeof spaceName === "string" ? spaceName.trim() : "";
+  if (!spaceArg) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
   const messages = readMessages({
-    channel: channelName,
+    space: spaceArg,
     since: opts.since,
     limit: opts.limit
   });
@@ -32483,55 +34294,78 @@ channel.command("read").description("Read messages from a channel").argument("<c
     console.log(JSON.stringify(messages, null, 2));
   } else {
     if (messages.length === 0) {
-      console.log(chalk2.dim(`No messages in #${channelName}.`));
+      console.log(chalk2.dim(`No messages in #${spaceArg}.`));
     } else {
       for (const msg of messages) {
         const time3 = chalk2.dim(msg.created_at.slice(11, 19));
         const from = chalk2.cyan(msg.from_agent);
         const priority = msg.priority !== "normal" ? chalk2.red(` [${msg.priority}]`) : "";
-        console.log(`${time3} ${from} \u2192 ${chalk2.magenta(`#${channelName}`)}${priority}: ${msg.content}`);
+        console.log(`${time3} ${from} \u2192 ${chalk2.magenta(`#${spaceArg}`)}${priority}: ${msg.content}`);
       }
     }
   }
   closeDb();
 });
-channel.command("join").description("Join a channel").argument("<channel>", "Channel name").option("--from <agent>", "Agent ID").option("--json", "Output as JSON").action((channelName, opts) => {
-  const agent = resolveIdentity(opts.from);
-  const ok = joinChannel(channelName, agent);
+space.command("join").description("Join a space").argument("<space>", "Space name").option("--from <agent>", "Agent ID").option("--json", "Output as JSON").action((spaceName, opts) => {
+  const agent = resolveIdentity(opts.from).trim();
+  const spaceArg = typeof spaceName === "string" ? spaceName.trim() : "";
+  if (!agent) {
+    console.error(chalk2.red("Agent identity is required."));
+    process.exit(1);
+  }
+  if (!spaceArg) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
+  const ok = joinSpace(spaceArg, agent);
   if (!ok) {
-    console.error(chalk2.red(`Channel #${channelName} not found.`));
+    console.error(chalk2.red(`Space #${spaceArg} not found.`));
     process.exit(1);
   }
   if (opts.json) {
-    console.log(JSON.stringify({ channel: channelName, agent, joined: true }));
+    console.log(JSON.stringify({ space: spaceArg, agent, joined: true }));
   } else {
-    console.log(chalk2.green(`${agent} joined #${channelName}`));
+    console.log(chalk2.green(`${agent} joined #${spaceArg}`));
   }
   closeDb();
 });
-channel.command("leave").description("Leave a channel").argument("<channel>", "Channel name").option("--from <agent>", "Agent ID").option("--json", "Output as JSON").action((channelName, opts) => {
-  const agent = resolveIdentity(opts.from);
-  const ok = leaveChannel(channelName, agent);
+space.command("leave").description("Leave a space").argument("<space>", "Space name").option("--from <agent>", "Agent ID").option("--json", "Output as JSON").action((spaceName, opts) => {
+  const agent = resolveIdentity(opts.from).trim();
+  const spaceArg = typeof spaceName === "string" ? spaceName.trim() : "";
+  if (!agent) {
+    console.error(chalk2.red("Agent identity is required."));
+    process.exit(1);
+  }
+  if (!spaceArg) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
+  const ok = leaveSpace(spaceArg, agent);
   if (opts.json) {
-    console.log(JSON.stringify({ channel: channelName, agent, left: ok }));
+    console.log(JSON.stringify({ space: spaceArg, agent, left: ok }));
   } else {
     if (ok) {
-      console.log(chalk2.green(`${agent} left #${channelName}`));
+      console.log(chalk2.green(`${agent} left #${spaceArg}`));
     } else {
-      console.log(chalk2.dim(`${agent} was not a member of #${channelName}`));
+      console.log(chalk2.dim(`${agent} was not a member of #${spaceArg}`));
     }
   }
   closeDb();
 });
-channel.command("members").description("List channel members").argument("<channel>", "Channel name").option("--json", "Output as JSON").action((channelName, opts) => {
-  const members = getChannelMembers(channelName);
+space.command("members").description("List space members").argument("<space>", "Space name").option("--json", "Output as JSON").action((spaceName, opts) => {
+  const spaceArg = typeof spaceName === "string" ? spaceName.trim() : "";
+  if (!spaceArg) {
+    console.error(chalk2.red("Space name cannot be empty."));
+    process.exit(1);
+  }
+  const members = getSpaceMembers(spaceArg);
   if (opts.json) {
     console.log(JSON.stringify(members, null, 2));
   } else {
     if (members.length === 0) {
-      console.log(chalk2.dim(`No members in #${channelName}.`));
+      console.log(chalk2.dim(`No members in #${spaceArg}.`));
     } else {
-      console.log(chalk2.magenta(`#${channelName}`) + chalk2.dim(` \u2014 ${members.length} member(s)`));
+      console.log(chalk2.magenta(`#${spaceArg}`) + chalk2.dim(` \u2014 ${members.length} member(s)`));
       for (const m of members) {
         console.log(`  ${chalk2.cyan(m.agent)} ${chalk2.dim(`joined ${m.joined_at.slice(0, 10)}`)}`);
       }
@@ -32539,13 +34373,245 @@ channel.command("members").description("List channel members").argument("<channe
   }
   closeDb();
 });
+var project = program2.command("project").description("Manage projects");
+project.command("create").description("Create a new project").argument("<name>", "Project name").option("--description <text>", "Project description").option("--path <path>", "Project path on disk").option("--repository <url>", "Repository URL").option("--tags <json>", "JSON array of tags").option("--from <agent>", "Creator agent ID").option("--json", "Output as JSON").action((name, opts) => {
+  const agent = resolveIdentity(opts.from).trim();
+  const projectName = typeof name === "string" ? name.trim() : "";
+  if (!agent) {
+    console.error(chalk2.red("Creator identity is required."));
+    process.exit(1);
+  }
+  if (!projectName) {
+    console.error(chalk2.red("Project name cannot be empty."));
+    process.exit(1);
+  }
+  let tags;
+  if (opts.tags) {
+    try {
+      tags = JSON.parse(opts.tags);
+    } catch {
+      console.error(chalk2.red("Invalid --tags JSON. Expected array of strings."));
+      process.exit(1);
+    }
+  }
+  try {
+    const p = createProject({
+      name: projectName,
+      created_by: agent,
+      description: opts.description,
+      path: opts.path,
+      repository: opts.repository,
+      tags
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(p, null, 2));
+    } else {
+      console.log(chalk2.green(`Project "${p.name}" created`) + chalk2.dim(` (id: ${p.id})`));
+    }
+  } catch (e) {
+    if (e.message?.includes("UNIQUE constraint")) {
+      console.error(chalk2.red(`Project "${projectName}" already exists.`));
+      process.exit(1);
+    }
+    console.error(chalk2.red(e.message));
+    process.exit(1);
+  }
+  closeDb();
+});
+project.command("list").description("List all projects").option("--status <status>", "Filter by status (active/archived)").option("--json", "Output as JSON").action((opts) => {
+  const status = opts.status === "active" || opts.status === "archived" ? opts.status : undefined;
+  const projects = listProjects(status ? { status } : undefined);
+  if (opts.json) {
+    console.log(JSON.stringify(projects, null, 2));
+  } else {
+    if (projects.length === 0) {
+      console.log(chalk2.dim("No projects found."));
+    } else {
+      for (const p of projects) {
+        const desc = p.description ? chalk2.dim(` \u2014 ${p.description}`) : "";
+        const statusBadge = p.status === "archived" ? chalk2.yellow(" [archived]") : "";
+        console.log(`${chalk2.bold(p.name)}${desc}${statusBadge}  ${p.space_count} spaces`);
+      }
+    }
+  }
+  closeDb();
+});
+project.command("get").description("Get project details").argument("<id-or-name>", "Project ID or name").option("--json", "Output as JSON").action((idOrName, opts) => {
+  let p = getProject(idOrName);
+  if (!p)
+    p = getProjectByName(idOrName);
+  if (!p) {
+    console.error(chalk2.red(`Project "${idOrName}" not found.`));
+    process.exit(1);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(p, null, 2));
+  } else {
+    console.log(chalk2.bold(p.name));
+    if (p.description)
+      console.log(`  Description: ${p.description}`);
+    if (p.path)
+      console.log(`  Path: ${p.path}`);
+    if (p.repository)
+      console.log(`  Repository: ${p.repository}`);
+    console.log(`  Status: ${p.status}`);
+    console.log(`  Spaces: ${p.space_count}`);
+    if (p.tags.length > 0)
+      console.log(`  Tags: ${p.tags.join(", ")}`);
+    console.log(`  Created by: ${p.created_by} on ${p.created_at.slice(0, 10)}`);
+  }
+  closeDb();
+});
+project.command("update").description("Update a project").argument("<id>", "Project ID").option("--name <name>", "New name").option("--description <text>", "New description").option("--path <path>", "New path").option("--status <status>", "New status (active/archived)").option("--repository <url>", "New repository URL").option("--tags <json>", "New tags (JSON array)").option("--json", "Output as JSON").action((id, opts) => {
+  const updates = {};
+  if (opts.name)
+    updates.name = opts.name;
+  if (opts.description)
+    updates.description = opts.description;
+  if (opts.path)
+    updates.path = opts.path;
+  if (opts.status)
+    updates.status = opts.status;
+  if (opts.repository)
+    updates.repository = opts.repository;
+  if (opts.tags) {
+    try {
+      updates.tags = JSON.parse(opts.tags);
+    } catch {
+      console.error(chalk2.red("Invalid --tags JSON."));
+      process.exit(1);
+    }
+  }
+  try {
+    const p = updateProject(id, updates);
+    if (opts.json) {
+      console.log(JSON.stringify(p, null, 2));
+    } else {
+      console.log(chalk2.green(`Project "${p.name}" updated.`));
+    }
+  } catch (e) {
+    console.error(chalk2.red(e.message));
+    process.exit(1);
+  }
+  closeDb();
+});
+project.command("delete").description("Delete a project").argument("<id>", "Project ID").option("--json", "Output as JSON").action((id, opts) => {
+  try {
+    const deleted = deleteProject(id);
+    if (!deleted) {
+      console.error(chalk2.red(`Project "${id}" not found.`));
+      process.exit(1);
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ id, deleted: true }));
+    } else {
+      console.log(chalk2.green(`Project deleted.`));
+    }
+  } catch (e) {
+    console.error(chalk2.red(e.message));
+    process.exit(1);
+  }
+  closeDb();
+});
+program2.command("delete").description("Delete a message (only sender can delete)").argument("<id>", "Message ID", parseInt).option("--from <agent>", "Sender agent ID").option("--json", "Output as JSON").action((id, opts) => {
+  const agent = resolveIdentity(opts.from).trim();
+  if (!agent) {
+    console.error(chalk2.red("Agent identity is required."));
+    process.exit(1);
+  }
+  const result = deleteMessage(id, agent);
+  if (opts.json) {
+    console.log(JSON.stringify({ id, deleted: result }));
+  } else {
+    if (result) {
+      console.log(chalk2.green(`Message #${id} deleted.`));
+    } else {
+      console.error(chalk2.red(`Message #${id} not found or not your message.`));
+      process.exit(1);
+    }
+  }
+  closeDb();
+});
+program2.command("edit").description("Edit a message (only sender can edit)").argument("<id>", "Message ID", parseInt).argument("<new-content>", "New message content").option("--from <agent>", "Sender agent ID").option("--json", "Output as JSON").action((id, newContent, opts) => {
+  const agent = resolveIdentity(opts.from).trim();
+  const content = typeof newContent === "string" ? newContent : "";
+  if (!agent) {
+    console.error(chalk2.red("Agent identity is required."));
+    process.exit(1);
+  }
+  if (!content.trim()) {
+    console.error(chalk2.red("New content cannot be empty."));
+    process.exit(1);
+  }
+  const msg = editMessage(id, agent, content);
+  if (opts.json) {
+    console.log(JSON.stringify(msg, null, 2));
+  } else {
+    if (msg) {
+      console.log(chalk2.green(`Message #${id} edited.`));
+    } else {
+      console.error(chalk2.red(`Message #${id} not found or not your message.`));
+      process.exit(1);
+    }
+  }
+  closeDb();
+});
+program2.command("pin").description("Pin a message").argument("<id>", "Message ID", parseInt).option("--json", "Output as JSON").action((id, opts) => {
+  const msg = pinMessage(id);
+  if (opts.json) {
+    console.log(JSON.stringify(msg, null, 2));
+  } else {
+    if (msg) {
+      console.log(chalk2.green(`Message #${id} pinned.`));
+    } else {
+      console.error(chalk2.red(`Message #${id} not found.`));
+      process.exit(1);
+    }
+  }
+  closeDb();
+});
+program2.command("unpin").description("Unpin a message").argument("<id>", "Message ID", parseInt).option("--json", "Output as JSON").action((id, opts) => {
+  const msg = unpinMessage(id);
+  if (opts.json) {
+    console.log(JSON.stringify(msg, null, 2));
+  } else {
+    if (msg) {
+      console.log(chalk2.green(`Message #${id} unpinned.`));
+    } else {
+      console.error(chalk2.red(`Message #${id} not found.`));
+      process.exit(1);
+    }
+  }
+  closeDb();
+});
+program2.command("agents").description("List all agents with their presence status").option("--online", "Only show online agents").option("--json", "Output as JSON").action((opts) => {
+  const agent = resolveIdentity();
+  heartbeat(agent);
+  const agents = listAgents({ online_only: opts.online });
+  if (opts.json) {
+    console.log(JSON.stringify(agents, null, 2));
+  } else {
+    if (agents.length === 0) {
+      console.log(chalk2.dim("No agents found."));
+    } else {
+      for (const a of agents) {
+        const status = a.online ? chalk2.green("online") : chalk2.dim("offline");
+        const lastSeen = chalk2.dim(a.last_seen_at.slice(0, 19));
+        const agentName = a.agent === agent ? chalk2.cyan(`${a.agent} (you)`) : chalk2.cyan(a.agent);
+        console.log(`  ${agentName}  ${status}  ${chalk2.dim(a.status)}  ${lastSeen}`);
+      }
+    }
+  }
+  closeDb();
+});
 program2.command("mcp").description("Start MCP server").action(async () => {
   const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_mcp2(), exports_mcp));
   await startMcpServer2();
 });
-program2.command("dashboard").description("Start web dashboard").option("--port <port>", "Port to listen on", parseInt).action(async (opts) => {
+program2.command("dashboard").description("Start web dashboard").option("--port <port>", "Port to listen on", parseInt).option("--host <host>", "Host to bind (default: 127.0.0.1)").action(async (opts) => {
   const { startDashboardServer: startDashboardServer2 } = await Promise.resolve().then(() => (init_serve(), exports_serve));
-  startDashboardServer2(opts.port || 3456);
+  const port = Number.isFinite(opts.port) && opts.port >= 0 && opts.port <= 65535 ? opts.port : 3456;
+  startDashboardServer2(port, opts.host);
 });
 program2.action(() => {
   const agent = resolveIdentity();