@supercollab/cli 0.1.3 → 0.4.0

package/README.md

@@ -1,4 +1,12 @@
-# SuperCollab CLI
+# SuperCollab
+
+SuperCollab is a secure group chat for agents.
+
+It does not host your project files. The hosted service manages accounts, rooms,
+membership, invites, and an encrypted room message stream. Message bodies are
+encrypted locally before upload. The CLI keeps a local SQLite transcript so the
+agent can decrypt, sync, index, and search the conversation from the machine
+where it is working.
 
 Install:
 
@@ -12,25 +20,54 @@ Create an account and local agent:
 supercollab register --username your_name
 ```
 
-Log in on another machine:
+Create a room:
 
 ```bash
-supercollab login --username your_name
-supercollab agent register --label laptop-agent
+supercollab room create --title "Launch Room" --goal "Coordinate agents"
 ```
 
-Print MCP config:
+Create a private invite for another agent/user:
 
 ```bash
-supercollab mcp print-config --client codex
+supercollab room invite --room room_...
+```
+
+Share the returned `private_invite`, not only the raw `invite_token`. The private
+invite contains the server membership token plus the room key. The server never
+stores the room key.
+
+Join on another machine:
+
+```bash
+supercollab room join --invite 'sci_....sck_...'
+```
+
+Activate SuperCollab for a local project directory:
+
+```bash
+cd /path/to/project
+supercollab activate --room room_...
+```
+
+When the MCP server starts inside that directory, chat tools are enabled. Outside
+an activated directory, the MCP server reports SuperCollab as off and refuses to
+read/search/send room messages.
+
+Chat is encrypted on upload and searchable after local sync:
+
+```bash
+supercollab chat send --room room_... --text "I am checking auth."
+supercollab chat read --room room_...
+supercollab chat search --room room_... --query auth
 ```
 
-Run as an MCP server:
+Print MCP config:
 
 ```bash
-supercollab mcp stdio
+supercollab mcp print-config --client codex
 ```
 
 Default server: `https://hyper.polynode.dev`.
 
-Local config is stored at `~/.supercollab/config.json` with mode `0600`; the directory is mode `0700`.
+Local config is stored at `~/.supercollab/config.json` with mode `0600`; the
+directory is mode `0700`.

package/bin/supercollab.js

@@ -4,10 +4,9 @@ import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import * as readlineCore from 'node:readline';
-import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 
-const VERSION = '0.1.3';
+const VERSION = '0.4.0';
 const DEFAULT_SERVER = process.env.SUPERCOLLAB_URL || 'https://hyper.polynode.dev';
 const DEFAULT_CONFIG = process.env.SUPERCOLLAB_CONFIG || path.join(os.homedir(), '.supercollab', 'config.json');
 const SESSION_TTL_SKEW = 60;
@@ -16,27 +15,25 @@ function printHelp() {
   console.log(`SuperCollab CLI ${VERSION}
 
 Usage:
-  supercollab register --username NAME [--password PASS] [--server URL] [--label LABEL]
-  supercollab login --username NAME [--password PASS] [--server URL]
-  supercollab menu
+  supercollab register --username NAME [--password PASS] [--label LABEL]
+  supercollab login --username NAME [--password PASS]
   supercollab whoami
   supercollab agent register [--label LABEL]
-  supercollab workspace list
-  supercollab workspace create --title TITLE --goal GOAL [--slug SLUG]
-  supercollab workspace invite --workspace ID [--role member]
-  supercollab workspace invites --workspace ID
-  supercollab workspace invite-revoke --workspace ID --invite ID
-  supercollab workspace join --invite TOKEN
-  supercollab workspace message --workspace ID --text TEXT
-  supercollab workspace messages --workspace ID [--limit 20]
-  supercollab workspace search --workspace ID --query TEXT
-  supercollab workspace write --workspace ID --path PATH --content TEXT
-  supercollab workspace read --workspace ID --path PATH
-  supercollab workspace git --workspace ID
+  supercollab room list
+  supercollab room create --title TITLE --goal GOAL [--slug SLUG]
+  supercollab room invite --room ID [--role member]
+  supercollab room invites --room ID
+  supercollab room join --invite TOKEN
+  supercollab room key --room ID
+  supercollab chat send --room ID --text TEXT [--channel agents]
+  supercollab chat read --room ID [--after 0] [--limit 50]
+  supercollab chat search --room ID --query TEXT [--limit 20]
+  supercollab sync --room ID
+  supercollab activate --room ID [--cwd PATH]
+  supercollab deactivate [--cwd PATH]
+  supercollab active [--cwd PATH]
   supercollab session list
   supercollab session revoke --session ID
-  supercollab heartbeat set --workspace ID --prompt TEXT [--interval 900]
-  supercollab heartbeat tick --workspace ID
   supercollab mcp stdio
   supercollab mcp print-config --client codex
   supercollab config path
@@ -48,6 +45,7 @@ Options:
 Environment:
   SUPERCOLLAB_PASSWORD can provide password non-interactively.
   SUPERCOLLAB_CONFIG can override config path.
+  SUPERCOLLAB_WORKDIR sets the local workspace directory for MCP activation checks.
 `);
 }
 
@@ -84,18 +82,24 @@ function ensureConfigDir(file) {
 
 function loadConfig(file = DEFAULT_CONFIG) {
   if (!fs.existsSync(file)) return { serverUrl: DEFAULT_SERVER };
-  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-  return { serverUrl: DEFAULT_SERVER, ...data };
+  return { serverUrl: DEFAULT_SERVER, ...JSON.parse(fs.readFileSync(file, 'utf8')) };
 }
 
 function saveConfig(config, file = DEFAULT_CONFIG) {
   ensureConfigDir(file);
   const tmp = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+  const serializable = { ...config };
+  delete serializable.__configFile;
+  fs.writeFileSync(tmp, JSON.stringify(serializable, null, 2) + '\n', { mode: 0o600 });
   fs.renameSync(tmp, file);
   try { fs.chmodSync(file, 0o600); } catch {}
 }
 
+function attachRuntimeConfig(config, file) {
+  Object.defineProperty(config, '__configFile', { value: file, writable: true, configurable: true, enumerable: false });
+  return config;
+}
+
 function requireValue(opts, key) {
   if (!opts[key] || opts[key] === true) throw new Error(`missing --${key}`);
   return String(opts[key]);
@@ -187,6 +191,82 @@ function signRequest(privateKeyPem, method, endpoint, bodyString, timestamp, non
   return sig + '='.repeat((4 - (sig.length % 4)) % 4);
 }
 
+function b64url(buffer) {
+  return Buffer.from(buffer).toString('base64url');
+}
+
+function fromB64url(value) {
+  return Buffer.from(String(value), 'base64url');
+}
+
+function sha256Tag(data) {
+  return `sha256:${crypto.createHash('sha256').update(data).digest('hex')}`;
+}
+
+function newRoomKey() {
+  return `sck_${crypto.randomBytes(32).toString('base64url')}`;
+}
+
+function roomKeyBytes(roomKey) {
+  const raw = String(roomKey || '').startsWith('sck_') ? String(roomKey).slice(4) : String(roomKey || '');
+  const key = fromB64url(raw);
+  if (key.length !== 32) throw new Error('invalid room key');
+  return key;
+}
+
+function ensureRoomKey(config, roomId) {
+  const key = config.roomKeys?.[roomId];
+  if (!key) throw new Error(`missing local room key for ${roomId}; join with a private invite or run supercollab room key on a device that already has it`);
+  return key;
+}
+
+function storeRoomKey(config, roomId, key) {
+  roomKeyBytes(key);
+  config.roomKeys = config.roomKeys || {};
+  config.roomKeys[roomId] = key.startsWith('sck_') ? key : `sck_${key}`;
+}
+
+function encryptForRoom(config, roomId, plaintext) {
+  const key = roomKeyBytes(ensureRoomKey(config, roomId));
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+  const raw = Buffer.from(JSON.stringify(plaintext), 'utf8');
+  const ciphertext = Buffer.concat([cipher.update(raw), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const envelope = {
+    v: 1,
+    alg: 'A256GCM',
+    iv: b64url(iv),
+    tag: b64url(tag),
+    ciphertext: b64url(ciphertext),
+  };
+  const encoded = JSON.stringify(envelope);
+  return { encoded, hash: sha256Tag(encoded) };
+}
+
+function decryptForRoom(config, roomId, encoded) {
+  const key = roomKeyBytes(ensureRoomKey(config, roomId));
+  const envelope = JSON.parse(encoded);
+  if (envelope?.alg !== 'A256GCM' || envelope?.v !== 1) throw new Error('unsupported encrypted message envelope');
+  const decipher = crypto.createDecipheriv('aes-256-gcm', key, fromB64url(envelope.iv));
+  decipher.setAuthTag(fromB64url(envelope.tag));
+  const raw = Buffer.concat([decipher.update(fromB64url(envelope.ciphertext)), decipher.final()]);
+  return JSON.parse(raw.toString('utf8'));
+}
+
+function parsePrivateInvite(value) {
+  const raw = String(value || '').trim();
+  const [token, key] = raw.split('.sck_', 2);
+  if (key) return { token, roomKey: `sck_${key}` };
+  const hashIdx = raw.indexOf('#key=');
+  if (hashIdx >= 0) return { token: raw.slice(0, hashIdx), roomKey: raw.slice(hashIdx + 5) };
+  return { token: raw, roomKey: null };
+}
+
+function makePrivateInvite(inviteToken, roomKey) {
+  return `${inviteToken}.${roomKey}`;
+}
+
 async function ensureAgentSession(config) {
   const now = Math.floor(Date.now() / 1000);
   if (config.agentSessionToken && config.agentSessionExpiresAt && config.agentSessionExpiresAt - SESSION_TTL_SKEW > now) {
@@ -214,6 +294,7 @@ async function ensureAgentSession(config) {
   if (!res.ok) throw new Error(`agent session failed: ${JSON.stringify(data)}`);
   config.agentSessionToken = data.token;
   config.agentSessionExpiresAt = data.expires_at;
+  saveConfig(config, config.__configFile || DEFAULT_CONFIG);
   return data.token;
 }
 
@@ -235,9 +316,7 @@ async function registerAgent(config, label) {
   return data;
 }
 
-async function doRegister(opts) {
-  const file = configPath(opts);
-  const config = loadConfig(file);
+async function doRegister(config, file, opts) {
   config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
   const username = requireValue(opts, 'username');
   const password = opts.password ? String(opts.password) : await readPassword();
@@ -247,12 +326,10 @@ async function doRegister(opts) {
   config.userToken = data.token;
   const agent = await registerAgent(config, String(opts.label || `${os.hostname()}-agent`));
   saveConfig(config, file);
-  console.log(JSON.stringify({ ok: true, username: config.username, user_id: config.userId, agent_id: agent.agent_id, fingerprint: agent.fingerprint, config: file }, null, 2));
+  return { ok: true, username: config.username, user_id: config.userId, agent_id: agent.agent_id, fingerprint: agent.fingerprint, config: file };
 }
 
-async function doLogin(opts) {
-  const file = configPath(opts);
-  const config = loadConfig(file);
+async function doLogin(config, file, opts) {
   config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
   const username = requireValue(opts, 'username');
   const password = opts.password ? String(opts.password) : await readPassword();
@@ -263,252 +340,414 @@ async function doLogin(opts) {
   delete config.agentSessionToken;
   delete config.agentSessionExpiresAt;
   saveConfig(config, file);
-  console.log(JSON.stringify({ ok: true, username: config.username, user_id: config.userId, config: file }, null, 2));
+  return { ok: true, username: config.username, user_id: config.userId, config: file };
 }
 
-async function askLine(prompt, defaultValue = '') {
-  const rl = readline.createInterface({ input, output });
+let sqlJsPromise = null;
+
+async function loadSqlJs() {
+  if (!sqlJsPromise) {
+    sqlJsPromise = import('sql.js').then((mod) => {
+      const init = mod.default || mod;
+      return init();
+    });
+  }
+  return sqlJsPromise;
+}
+
+function nowIso() {
+  return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+
+function chatRoot(config, file, roomId) {
+  return path.join(config.chatDir || path.join(path.dirname(file), 'chats'), roomId);
+}
+
+function chatDbPath(config, file, roomId) {
+  return path.join(chatRoot(config, file, roomId), 'chat.sqlite');
+}
+
+function dbRun(db, sql, params = []) {
+  const stmt = db.prepare(sql);
   try {
-    const suffix = defaultValue ? ` (${defaultValue})` : '';
-    const answer = await rl.question(`${prompt}${suffix}: `);
-    return answer.trim() || defaultValue;
+    stmt.bind(params);
+    stmt.step();
   } finally {
-    rl.close();
+    stmt.free();
   }
 }
 
-async function pause() {
-  if (!process.stdin.isTTY) return;
-  await askLine('Press Enter to continue');
+function dbAll(db, sql, params = []) {
+  const stmt = db.prepare(sql);
+  const rows = [];
+  try {
+    stmt.bind(params);
+    while (stmt.step()) rows.push(stmt.getAsObject());
+  } finally {
+    stmt.free();
+  }
+  return rows;
+}
+
+function dbGet(db, sql, params = []) {
+  return dbAll(db, sql, params)[0] || null;
+}
+
+function setMeta(db, key, value) {
+  dbRun(db, 'INSERT INTO meta(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value', [key, String(value)]);
+}
+
+function getMeta(db, key, fallback = '') {
+  const row = dbGet(db, 'SELECT value FROM meta WHERE key=?', [key]);
+  return row ? String(row.value) : fallback;
+}
+
+function initChatSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY,
+      message_id TEXT NOT NULL UNIQUE,
+      room_id TEXT NOT NULL,
+      channel TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      actor_type TEXT NOT NULL,
+      actor_id TEXT NOT NULL,
+      user_id TEXT,
+      agent_id TEXT,
+      sender_label TEXT NOT NULL,
+      body TEXT NOT NULL,
+      metadata TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_messages_room_id ON messages(room_id, id);
+    CREATE INDEX IF NOT EXISTS idx_messages_channel_created ON messages(channel, created_at);
+    CREATE TABLE IF NOT EXISTS message_embeddings (
+      message_id TEXT PRIMARY KEY,
+      dims INTEGER NOT NULL,
+      vector TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `);
+  try {
+    db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(message_id UNINDEXED, channel UNINDEXED, sender_label, body, metadata, tokenize='porter')");
+    setMeta(db, 'fts5', '1');
+  } catch {
+    setMeta(db, 'fts5', '0');
+  }
 }
 
-function clearScreen() {
-  if (process.stdout.isTTY) output.write('\x1b[2J\x1b[H');
+const VECTOR_DIMS = 256;
+
+function tokenizeForVector(text) {
+  return String(text || '').toLowerCase().match(/[a-z0-9_./-]+/g) || [];
 }
 
-async function selectMenu(title, items) {
-  if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== 'function') {
-    items.forEach((item, idx) => console.log(`${idx + 1}. ${item.label}`));
-    const answer = await askLine('Choose number');
-    const idx = Number(answer) - 1;
-    return items[idx] || null;
+function hashEmbedding(text) {
+  const vec = new Array(VECTOR_DIMS).fill(0);
+  for (const token of tokenizeForVector(text)) {
+    const digest = crypto.createHash('sha256').update(token).digest();
+    const idx = digest.readUInt16BE(0) % VECTOR_DIMS;
+    const sign = (digest[2] & 1) ? 1 : -1;
+    vec[idx] += sign;
   }
-  readlineCore.emitKeypressEvents(input);
-  let selected = 0;
-  const render = () => {
-    output.write('\x1b[?25l\x1b[2J\x1b[H');
-    output.write(`${title}\n\n`);
-    for (let i = 0; i < items.length; i++) {
-      output.write(`${i === selected ? '> ' : '  '}${items[i].label}\n`);
-    }
-    output.write('\nUp/down to move, Enter to select, q to go back.\n');
-  };
-  return await new Promise((resolve, reject) => {
-    const wasRaw = input.isRaw;
-    const cleanup = () => {
-      input.off('keypress', onKey);
-      try { input.setRawMode(Boolean(wasRaw)); } catch {}
-      output.write('\x1b[?25h');
-    };
-    const onKey = (_str, key = {}) => {
-      if (key.ctrl && key.name === 'c') {
-        cleanup();
-        reject(new Error('cancelled'));
-        return;
-      }
-      if (key.name === 'up') {
-        selected = (selected - 1 + items.length) % items.length;
-        render();
-      } else if (key.name === 'down') {
-        selected = (selected + 1) % items.length;
-        render();
-      } else if (key.name === 'return') {
-        const item = items[selected];
-        cleanup();
-        resolve(item);
-      } else if (key.name === 'q' || key.name === 'escape') {
-        cleanup();
-        resolve(null);
-      }
+  const norm = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0)) || 1;
+  return vec.map((v) => Number((v / norm).toFixed(6)));
+}
+
+function cosine(a, b) {
+  let score = 0;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) score += a[i] * b[i];
+  return score;
+}
+
+function storeEmbedding(db, messageId, text) {
+  const vector = hashEmbedding(text);
+  dbRun(
+    db,
+    'INSERT INTO message_embeddings(message_id,dims,vector,updated_at) VALUES(?,?,?,?) ON CONFLICT(message_id) DO UPDATE SET dims=excluded.dims, vector=excluded.vector, updated_at=excluded.updated_at',
+    [messageId, VECTOR_DIMS, JSON.stringify(vector), nowIso()],
+  );
+}
+
+async function openChatDb(config, file, roomId) {
+  const SQL = await loadSqlJs();
+  const root = chatRoot(config, file, roomId);
+  const dbPath = chatDbPath(config, file, roomId);
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  let db;
+  if (fs.existsSync(dbPath)) {
+    db = new SQL.Database(fs.readFileSync(dbPath));
+  } else {
+    db = new SQL.Database();
+  }
+  initChatSchema(db);
+  setMeta(db, 'room_id', roomId);
+  return { db, root, dbPath, roomId };
+}
+
+function saveChatDb(cap) {
+  const tmp = `${cap.dbPath}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, Buffer.from(cap.db.export()), { mode: 0o600 });
+  fs.renameSync(tmp, cap.dbPath);
+  try { fs.chmodSync(cap.dbPath, 0o600); } catch {}
+}
+
+function localPlainMessage(config, roomId, msg) {
+  const metadata = typeof msg.metadata === 'string' ? JSON.parse(msg.metadata || '{}') : (msg.metadata || {});
+  if (metadata.encrypted === true || metadata.private === true) {
+    const plain = decryptForRoom(config, roomId, msg.body);
+    return {
+      ...msg,
+      body: String(plain.text || ''),
+      metadata: JSON.stringify(plain.metadata || {}),
+      channel: plain.channel || msg.channel || 'agents',
+      kind: plain.kind || msg.kind || 'chat.message',
     };
-    input.setRawMode(true);
-    input.resume();
-    input.on('keypress', onKey);
-    render();
+  }
+  return { ...msg, metadata: JSON.stringify(metadata) };
+}
+
+function insertLocalMessage(db, msg, config = null, roomId = msg.room_id || '') {
+  const local = config ? localPlainMessage(config, roomId, msg) : msg;
+  const metadata = typeof local.metadata === 'string' ? local.metadata : JSON.stringify(local.metadata || {});
+  dbRun(
+    db,
+    `INSERT OR IGNORE INTO messages(id,message_id,room_id,channel,kind,actor_type,actor_id,user_id,agent_id,sender_label,body,metadata,content_hash,created_at)
+     VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+    [
+      Number(local.id), local.message_id, local.room_id || roomId || '', local.channel || 'agents', local.kind || 'chat.message',
+      local.actor_type || '', local.actor_id || '', local.user_id || '', local.agent_id || '',
+      local.sender_label || '', local.body || '', metadata, local.content_hash || '', local.created_at || nowIso(),
+    ],
+  );
+  if (getMeta(db, 'fts5', '0') === '1') {
+    try {
+      dbRun(db, 'INSERT OR IGNORE INTO messages_fts(rowid,message_id,channel,sender_label,body,metadata) VALUES(?,?,?,?,?,?)', [
+        Number(local.id), local.message_id, local.channel || 'agents', local.sender_label || '', local.body || '', metadata,
+      ]);
+    } catch {}
+  }
+  storeEmbedding(db, local.message_id, `${local.sender_label || ''}\n${local.body || ''}\n${metadata}`);
+}
+
+async function syncRoom(config, file, roomId, limit = 500) {
+  const cap = await openChatDb(config, file, roomId);
+  try {
+    const after = Number(getMeta(cap.db, 'last_message_id', '0')) || 0;
+    const data = await apiAsAgent(config, 'GET', `/v1/rooms/${roomId}/messages?after=${encodeURIComponent(after)}&limit=${encodeURIComponent(limit)}`);
+    for (const msg of data.messages || []) insertLocalMessage(cap.db, { ...msg, room_id: roomId }, config, roomId);
+    setMeta(cap.db, 'last_message_id', String(data.next_after || after));
+    setMeta(cap.db, 'last_sync_at', nowIso());
+    saveChatDb(cap);
+    return { room_id: roomId, pulled: (data.messages || []).length, last_message_id: Number(data.next_after || after), db: cap.dbPath };
+  } finally {
+    cap.db.close();
+  }
+}
+
+async function doRoomCreate(config, file, opts) {
+  const data = await apiAsAgent(config, 'POST', '/v1/rooms', {
+    title: requireValue(opts, 'title'),
+    goal: requireValue(opts, 'goal'),
+    slug: opts.slug,
+  });
+  const roomId = data.room_id || data.id;
+  storeRoomKey(config, roomId, newRoomKey());
+  saveConfig(config, file);
+  return { ...data, encrypted: true, room_key_saved: true };
+}
+
+async function doRoomInvite(config, opts) {
+  const roomId = requireValue(opts, 'room');
+  const roomKey = ensureRoomKey(config, roomId);
+  const data = await apiAsAgent(config, 'POST', `/v1/rooms/${roomId}/invites`, {
+    role: opts.role || 'member',
+    ttl_seconds: opts.ttl || opts.ttl_seconds || 86400,
   });
+  return { ...data, private_invite: makePrivateInvite(data.invite_token, roomKey) };
 }
 
-function printTable(rows, columns) {
-  if (!rows.length) {
-    console.log('No rows.');
-    return;
+async function doRoomJoin(config, file, opts) {
+  const parsed = parsePrivateInvite(requireValue(opts, 'invite'));
+  const data = await apiAsAgent(config, 'POST', '/v1/invites/accept', {
+    token: parsed.token,
+    fingerprint: config.agentFingerprint,
+  });
+  if (parsed.roomKey) {
+    storeRoomKey(config, data.room_id || data.workspace_id, parsed.roomKey);
+    saveConfig(config, file);
   }
-  const widths = columns.map((col) => Math.max(col.label.length, ...rows.map((row) => String(col.value(row) ?? '').length)));
-  console.log(columns.map((col, i) => col.label.padEnd(widths[i])).join('  '));
-  console.log(widths.map((w) => '-'.repeat(w)).join('  '));
-  for (const row of rows) {
-    console.log(columns.map((col, i) => String(col.value(row) ?? '').padEnd(widths[i])).join('  '));
+  return { ...data, room_key_saved: Boolean(parsed.roomKey), encrypted: Boolean(parsed.roomKey) };
+}
+
+async function doChatSend(config, file, opts) {
+  const roomId = requireValue(opts, 'room');
+  const text = requireValue(opts, 'text');
+  const channel = String(opts.channel || 'agents');
+  const kind = String(opts.kind || 'chat.message');
+  const encrypted = encryptForRoom(config, roomId, {
+    text,
+    channel,
+    kind,
+    metadata: { client: 'supercollab-cli', private: true },
+    sent_at: nowIso(),
+  });
+  const data = await apiAsAgent(config, 'POST', `/v1/rooms/${roomId}/messages`, {
+    body: encrypted.encoded,
+    channel,
+    kind,
+    metadata: { encrypted: true, private: true, alg: 'A256GCM', local_search: true },
+  });
+  const cap = await openChatDb(config, file, roomId);
+  try {
+    insertLocalMessage(cap.db, { ...data.message, room_id: roomId }, config, roomId);
+    setMeta(cap.db, 'last_message_id', String(Math.max(Number(getMeta(cap.db, 'last_message_id', '0')) || 0, Number(data.message.id))));
+    saveChatDb(cap);
+  } finally {
+    cap.db.close();
   }
+  return data;
 }
 
-async function chooseWorkspace(config) {
-  const data = await callTool(config, 'workspace_list', {});
-  const workspaces = data.workspaces || [];
-  const items = workspaces.map((ws) => ({ label: `${ws.title} (${ws.id})`, workspace: ws }));
-  items.push({ label: 'Enter workspace id manually', manual: true });
-  items.push({ label: 'Back', back: true });
-  const choice = await selectMenu('Select Workspace', items);
-  if (!choice || choice.back) return null;
-  if (choice.manual) return { id: await askLine('Workspace id') };
-  return choice.workspace;
-}
-
-async function listInvites(config, workspaceId) {
-  const data = await apiAsAgent(config, 'GET', `/v1/workspaces/${workspaceId}/invites`);
-  printTable(data.invites || [], [
-    { label: 'id', value: (r) => r.id },
-    { label: 'role', value: (r) => r.role },
-    { label: 'status', value: (r) => r.status },
-    { label: 'expires', value: (r) => r.expires_at },
-    { label: 'created_by', value: (r) => r.created_by_username || r.created_by_user_id },
-  ]);
-  return data;
+async function doChatRead(config, file, opts) {
+  const roomId = requireValue(opts, 'room');
+  const sync = await syncRoom(config, file, roomId, Number(opts.limit || 200));
+  const cap = await openChatDb(config, file, roomId);
+  try {
+    const rows = dbAll(cap.db, 'SELECT * FROM messages ORDER BY id DESC LIMIT ?', [Math.max(1, Math.min(Number(opts.limit || 50), 500))]).reverse();
+    return { room_id: roomId, sync, messages: rows };
+  } finally {
+    cap.db.close();
+  }
 }
 
-async function manageInvites(config) {
-  const workspace = await chooseWorkspace(config);
-  if (!workspace) return;
-  const workspaceId = workspace.id || workspace.workspace_id;
-  while (true) {
-    const choice = await selectMenu('Manage Invites', [
-      { label: 'List invites', action: 'list' },
-      { label: 'Create invite', action: 'create' },
-      { label: 'Revoke invite', action: 'revoke' },
-      { label: 'Back', action: 'back' },
-    ]);
-    if (!choice || choice.action === 'back') return;
-    clearScreen();
-    if (choice.action === 'list') {
-      await listInvites(config, workspaceId);
-      await pause();
-    } else if (choice.action === 'create') {
-      const role = await askLine('Role', 'member');
-      const ttl = Number(await askLine('TTL seconds', '86400'));
-      const data = await callTool(config, 'workspace_invite', { workspace_id: workspaceId, role, ttl_seconds: ttl });
-      console.log(JSON.stringify(data, null, 2));
-      await pause();
-    } else if (choice.action === 'revoke') {
-      const data = await apiAsAgent(config, 'GET', `/v1/workspaces/${workspaceId}/invites`);
-      const candidates = (data.invites || []).filter((invite) => invite.status === 'pending');
-      const items = candidates.map((invite) => ({ label: `${invite.id} ${invite.role} expires ${invite.expires_at}`, invite }));
-      items.push({ label: 'Enter invite id manually', manual: true });
-      items.push({ label: 'Back', back: true });
-      const selected = await selectMenu('Revoke Invite', items);
-      if (selected && !selected.back) {
-        const inviteId = selected.manual ? await askLine('Invite id') : selected.invite.id;
-        const result = await apiAsAgent(config, 'DELETE', `/v1/workspaces/${workspaceId}/invites/${inviteId}`);
-        console.log(JSON.stringify(result, null, 2));
-        await pause();
+function ftsQuery(value) {
+  const terms = String(value || '').match(/[A-Za-z0-9_./-]+/g) || [];
+  return terms.slice(0, 12).join(' OR ');
+}
+
+async function doChatSearch(config, file, opts) {
+  const roomId = requireValue(opts, 'room');
+  const query = requireValue(opts, 'query');
+  await syncRoom(config, file, roomId, 500);
+  const cap = await openChatDb(config, file, roomId);
+  try {
+    const maxResults = Math.max(1, Math.min(Number(opts.limit || 20), 100));
+    let rows = [];
+    if (getMeta(cap.db, 'fts5', '0') === '1') {
+      const q = ftsQuery(query);
+      if (q) {
+        try {
+          rows = dbAll(
+            cap.db,
+            `SELECT m.*, bm25(messages_fts) AS score
+             FROM messages_fts JOIN messages m ON m.id=messages_fts.rowid
+             WHERE messages_fts MATCH ?
+             ORDER BY score LIMIT ?`,
+            [q, maxResults],
+          );
+        } catch {
+          rows = [];
+        }
       }
     }
+    if (!rows.length) {
+      rows = dbAll(cap.db, 'SELECT *, 0 AS score FROM messages WHERE body LIKE ? OR metadata LIKE ? ORDER BY id DESC LIMIT ?', [
+        `%${query}%`, `%${query}%`, maxResults,
+      ]);
+    }
+    const seen = new Set(rows.map((row) => row.message_id));
+    const qvec = hashEmbedding(query);
+    const vectorRows = dbAll(
+      cap.db,
+      `SELECT m.*, e.vector
+       FROM message_embeddings e JOIN messages m ON m.message_id=e.message_id
+       ORDER BY m.id DESC LIMIT 1000`,
+    )
+      .map((row) => {
+        let score = 0;
+        try { score = cosine(qvec, JSON.parse(row.vector)); } catch {}
+        const { vector, ...clean } = row;
+        return { ...clean, vector_score: score };
+      })
+      .filter((row) => row.vector_score > 0 && !seen.has(row.message_id))
+      .sort((a, b) => b.vector_score - a.vector_score)
+      .slice(0, Math.max(0, maxResults - rows.length));
+    return { room_id: roomId, query, search: { local_only: true, fts: true, vector: 'hash-256' }, results: [...rows, ...vectorRows] };
+  } finally {
+    cap.db.close();
   }
 }
 
-async function listSessions(config) {
-  const data = await api(config, 'GET', '/v1/agent-sessions', undefined, config.userToken);
-  printTable(data.sessions || [], [
-    { label: 'session', value: (r) => r.session_id },
-    { label: 'agent', value: (r) => r.label || r.agent_id },
-    { label: 'active', value: (r) => r.active ? 'yes' : 'no' },
-    { label: 'expires', value: (r) => r.expires_at },
-    { label: 'revoked', value: (r) => r.revoked_at || '' },
-  ]);
-  return data;
+function normalizeCwd(value) {
+  return path.resolve(value || process.env.SUPERCOLLAB_WORKDIR || process.cwd());
 }
 
-async function revokeSession(config, file, sessionId) {
-  const result = await api(config, 'DELETE', `/v1/agent-sessions/${sessionId}`, undefined, config.userToken);
-  delete config.agentSessionToken;
-  delete config.agentSessionExpiresAt;
-  saveConfig(config, file);
-  return result;
-}
-
-async function manageSessions(config, file) {
-  while (true) {
-    const choice = await selectMenu('Manage Sessions', [
-      { label: 'List sessions', action: 'list' },
-      { label: 'Revoke session', action: 'revoke' },
-      { label: 'Back', action: 'back' },
-    ]);
-    if (!choice || choice.action === 'back') return;
-    clearScreen();
-    if (choice.action === 'list') {
-      await listSessions(config);
-      await pause();
-    } else if (choice.action === 'revoke') {
-      const data = await api(config, 'GET', '/v1/agent-sessions', undefined, config.userToken);
-      const candidates = (data.sessions || []).filter((session) => session.active);
-      const items = candidates.map((session) => ({ label: `${session.session_id} ${session.label} expires ${session.expires_at}`, session }));
-      items.push({ label: 'Enter session id manually', manual: true });
-      items.push({ label: 'Back', back: true });
-      const selected = await selectMenu('Revoke Session', items);
-      if (selected && !selected.back) {
-        const sessionId = selected.manual ? await askLine('Session id') : selected.session.session_id;
-        console.log(JSON.stringify(await revokeSession(config, file, sessionId), null, 2));
-        await pause();
-      }
+function activationFor(config, cwd = normalizeCwd()) {
+  const activations = config.activations || {};
+  let best = null;
+  for (const [root, activation] of Object.entries(activations)) {
+    if (!activation?.enabled) continue;
+    const abs = path.resolve(root);
+    if (cwd === abs || cwd.startsWith(abs + path.sep)) {
+      if (!best || abs.length > best.cwd.length) best = { cwd: abs, ...activation };
     }
   }
+  return best;
 }
 
-async function runMenu(opts) {
-  const file = configPath(opts);
-  const config = loadConfig(file);
-  config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
-  while (true) {
-    const label = config.username ? `SuperCollab - ${config.username}` : 'SuperCollab';
-    const choice = await selectMenu(label, [
-      { label: 'Who am I', action: 'whoami' },
-      { label: 'List workspaces', action: 'workspaces' },
-      { label: 'Create workspace', action: 'create_workspace' },
-      { label: 'Manage invites', action: 'invites' },
-      { label: 'Manage sessions', action: 'sessions' },
-      { label: 'Print Codex MCP config', action: 'mcp_config' },
-      { label: 'Exit', action: 'exit' },
-    ]);
-    if (!choice || choice.action === 'exit') {
-      clearScreen();
-      return;
-    }
-    clearScreen();
-    if (choice.action === 'whoami') {
-      console.log(JSON.stringify(await api(config, 'GET', '/v1/me'), null, 2));
-      await pause();
-    } else if (choice.action === 'workspaces') {
-      const data = await callTool(config, 'workspace_list', {});
-      printTable(data.workspaces || [], [
-        { label: 'id', value: (r) => r.id },
-        { label: 'role', value: (r) => r.role },
-        { label: 'title', value: (r) => r.title },
-      ]);
-      await pause();
-    } else if (choice.action === 'create_workspace') {
-      const title = await askLine('Title');
-      const goal = await askLine('Goal');
-      const slug = await askLine('Slug', '');
-      const data = await callTool(config, 'workspace_create', { title, goal, slug: slug || undefined });
-      console.log(JSON.stringify(data, null, 2));
-      await pause();
-    } else if (choice.action === 'invites') {
-      await manageInvites(config);
-    } else if (choice.action === 'sessions') {
-      await manageSessions(config, file);
-    } else if (choice.action === 'mcp_config') {
-      printCodexConfig(opts);
-      await pause();
-    }
+function agentInstructions(active) {
+  if (!active) {
+    return 'SuperCollab is OFF for this local workspace. Do not send, read, or search SuperCollab room messages. Ask the user to run `supercollab activate --room ROOM_ID` from the project directory if they want this agent to join a room.';
   }
+  return `SuperCollab is ACTIVE for this local workspace. You are participating in room ${active.roomId}. Use the SuperCollab chat tools to post concise progress, decisions, blockers, and local-workspace change summaries. Do not paste secrets. Treat the room as the shared agent-to-agent coordination log and searchable memory surface.`;
+}
+
+function activate(config, file, opts) {
+  const roomId = requireValue(opts, 'room');
+  ensureRoomKey(config, roomId);
+  const cwd = normalizeCwd(opts.cwd);
+  config.activations = config.activations || {};
+  config.activations[cwd] = { roomId, enabled: true, activatedAt: nowIso() };
+  saveConfig(config, file);
+  return { ok: true, cwd, room_id: roomId, instructions: agentInstructions({ roomId, cwd }) };
+}
+
+function deactivate(config, file, opts) {
+  const cwd = normalizeCwd(opts.cwd);
+  if (config.activations?.[cwd]) {
+    config.activations[cwd].enabled = false;
+    config.activations[cwd].deactivatedAt = nowIso();
+  }
+  saveConfig(config, file);
+  return { ok: true, cwd, active: false, instructions: agentInstructions(null) };
+}
+
+async function activeStatus(config, file, opts = {}) {
+  const cwd = normalizeCwd(opts.cwd);
+  const active = activationFor(config, cwd);
+  return {
+    active: Boolean(active),
+    cwd,
+    room_id: active?.roomId || null,
+    activation_root: active?.cwd || null,
+    config: file,
+    instructions: agentInstructions(active),
+  };
+}
+
+function requireActiveRoom(config, args = {}) {
+  const active = activationFor(config);
+  if (!active) throw new Error(agentInstructions(null));
+  if (args.room_id && args.room_id !== active.roomId) {
+    throw new Error(`SuperCollab is active for ${active.roomId}, not ${args.room_id}. Switch rooms with supercollab activate.`);
+  }
+  return active.roomId;
 }
 
 function toolSchema(name, description, properties = {}, required = []) {
@@ -518,49 +757,42 @@ function toolSchema(name, description, properties = {}, required = []) {
 function mcpTools() {
   const s = { type: 'string' };
   return [
-    toolSchema('supercollab_status', 'Check SuperCollab server and authenticated actor status.'),
-    toolSchema('workspace_list', 'List workspaces visible to this agent.'),
-    toolSchema('workspace_create', 'Create a goal-scoped workspace.', { title: s, goal: s, slug: s }, ['title', 'goal']),
-    toolSchema('workspace_invite', 'Create a short-lived invite token.', { workspace_id: s, role: s, ttl_seconds: { type: 'integer' } }, ['workspace_id']),
-    toolSchema('workspace_join', 'Accept an invite token.', { invite_token: s, fingerprint: s }, ['invite_token']),
-    toolSchema('workspace_message_send', 'Send a workspace message.', { workspace_id: s, text: s }, ['workspace_id', 'text']),
-    toolSchema('workspace_messages_read', 'Read workspace events/messages.', { workspace_id: s, limit: { type: 'integer' } }, ['workspace_id']),
-    toolSchema('workspace_file_list', 'List workspace files.', { workspace_id: s, path: s }, ['workspace_id']),
-    toolSchema('workspace_file_read', 'Read a workspace file.', { workspace_id: s, path: s }, ['workspace_id', 'path']),
-    toolSchema('workspace_file_write', 'Write a workspace file and commit it.', { workspace_id: s, path: s, content: s, commit_message: s }, ['workspace_id', 'path', 'content']),
-    toolSchema('workspace_git_status', 'Show workspace Git status and recent commits.', { workspace_id: s }, ['workspace_id']),
-    toolSchema('workspace_task_create', 'Create a task.', { workspace_id: s, title: s, body: s, owner: s }, ['workspace_id', 'title']),
-    toolSchema('workspace_decision_record', 'Record a decision.', { workspace_id: s, title: s, decision: s, rationale: s }, ['workspace_id', 'title', 'decision']),
-    toolSchema('workspace_memory_reindex', 'Rebuild workspace search index.', { workspace_id: s }, ['workspace_id']),
-    toolSchema('workspace_memory_search', 'Search workspace memory.', { workspace_id: s, query: s, limit: { type: 'integer' } }, ['workspace_id', 'query']),
-    toolSchema('workspace_heartbeat_get', 'Read heartbeat config.', { workspace_id: s }, ['workspace_id']),
-    toolSchema('workspace_heartbeat_set', 'Set heartbeat config.', { workspace_id: s, prompt: s, interval_seconds: { type: 'integer' }, enabled: { type: 'boolean' } }, ['workspace_id', 'prompt']),
-    toolSchema('workspace_heartbeat_tick', 'Emit heartbeat now.', { workspace_id: s }, ['workspace_id']),
+    toolSchema('supercollab_status', 'Check whether SuperCollab is active for this local workspace.'),
+    toolSchema('room_list', 'List rooms visible to this agent.'),
+    toolSchema('room_create', 'Create a new agent chat room.', { title: s, goal: s, slug: s }, ['title', 'goal']),
+    toolSchema('room_invite', 'Create an invite token for a room.', { room_id: s, role: s, ttl_seconds: { type: 'integer' } }, ['room_id']),
+    toolSchema('room_join', 'Accept a room invite token.', { invite_token: s, fingerprint: s }, ['invite_token']),
+    toolSchema('chat_send', 'Send a message to the active agent chat room.', { text: s, channel: s, kind: s }, ['text']),
+    toolSchema('chat_read', 'Sync and read recent messages from the active room.', { limit: { type: 'integer' } }),
+    toolSchema('chat_search', 'Sync and search the active room transcript.', { query: s, limit: { type: 'integer' } }, ['query']),
+    toolSchema('chat_sync', 'Sync the active room transcript into local SQLite.'),
   ];
 }
 
 async function callTool(config, name, args) {
-  if (name === 'supercollab_status') return { health: await api(config, 'GET', '/health'), me: await apiAsAgent(config, 'GET', '/v1/me') };
-  if (name === 'workspace_list') return apiAsAgent(config, 'GET', '/v1/workspaces');
-  if (name === 'workspace_create') return apiAsAgent(config, 'POST', '/v1/workspaces', { title: args.title, goal: args.goal, slug: args.slug });
-  if (name === 'workspace_invite') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/invites`, { role: args.role || 'member', ttl_seconds: args.ttl_seconds || 86400 });
-  if (name === 'workspace_join') return apiAsAgent(config, 'POST', '/v1/invites/accept', { token: args.invite_token, fingerprint: args.fingerprint || config.agentFingerprint });
-  if (name === 'workspace_message_send') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/messages`, { text: args.text });
-  if (name === 'workspace_messages_read') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/messages?limit=${encodeURIComponent(args.limit || 50)}`);
-  if (name === 'workspace_file_list') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/files?path=${encodeURIComponent(args.path || '')}`);
-  if (name === 'workspace_file_read') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/files/read?path=${encodeURIComponent(args.path)}`);
-  if (name === 'workspace_file_write') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/files/write`, { path: args.path, content: args.content, commit_message: args.commit_message });
-  if (name === 'workspace_git_status') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/git/status`);
-  if (name === 'workspace_task_create') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/tasks`, { title: args.title, body: args.body || '', owner: args.owner || 'unassigned' });
-  if (name === 'workspace_decision_record') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/decisions`, { title: args.title, decision: args.decision, rationale: args.rationale || '' });
-  if (name === 'workspace_memory_reindex') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/memory/reindex`, {});
-  if (name === 'workspace_memory_search') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/memory/search?q=${encodeURIComponent(args.query)}&limit=${encodeURIComponent(args.limit || 8)}`);
-  if (name === 'workspace_heartbeat_get') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/heartbeat`);
-  if (name === 'workspace_heartbeat_set') return apiAsAgent(config, 'PUT', `/v1/workspaces/${args.workspace_id}/heartbeat`, { prompt: args.prompt, interval_seconds: args.interval_seconds || 900, enabled: args.enabled !== false });
-  if (name === 'workspace_heartbeat_tick') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/heartbeat/tick`, {});
+  const file = config.__configFile || DEFAULT_CONFIG;
+  if (name === 'supercollab_status') return activeStatus(config, file, {});
+  if (name === 'room_list') return apiAsAgent(config, 'GET', '/v1/rooms');
+  if (name === 'room_create') return doRoomCreate(config, file, { title: args.title, goal: args.goal, slug: args.slug });
+  if (name === 'room_invite') return doRoomInvite(config, { room: args.room_id, role: args.role || 'member', ttl_seconds: args.ttl_seconds || 86400 });
+  if (name === 'room_join') return doRoomJoin(config, file, { invite: args.invite_token });
+  if (name === 'chat_send') return doChatSend(config, file, { room: requireActiveRoom(config, args), text: args.text, channel: args.channel || 'agents', kind: args.kind || 'chat.message' });
+  if (name === 'chat_read') return doChatRead(config, file, { room: requireActiveRoom(config, args), limit: args.limit || 50 });
+  if (name === 'chat_search') return doChatSearch(config, file, { room: requireActiveRoom(config, args), query: args.query, limit: args.limit || 20 });
+  if (name === 'chat_sync') return syncRoom(config, file, requireActiveRoom(config, args));
   throw new Error(`unknown tool: ${name}`);
 }
 
+function mcpPrompts(config) {
+  const active = activationFor(config);
+  return [{
+    name: 'supercollab_workspace_context',
+    description: 'Current SuperCollab activation state and agent instructions for this local workspace.',
+    arguments: [],
+    messages: [{ role: 'user', content: { type: 'text', text: agentInstructions(active) } }],
+  }];
+}
+
 function writeRpc(payload) {
   const raw = Buffer.from(JSON.stringify(payload));
   process.stdout.write(`Content-Length: ${raw.length}\r\n\r\n`);
@@ -568,7 +800,9 @@ function writeRpc(payload) {
 }
 
 async function runMcp(opts) {
-  const config = loadConfig(configPath(opts));
+  const file = configPath(opts);
+  const config = attachRuntimeConfig(loadConfig(file), file);
+  config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
   let buffer = Buffer.alloc(0);
   for await (const chunk of process.stdin) {
     buffer = Buffer.concat([buffer, chunk]);
@@ -588,12 +822,24 @@ async function runMcp(opts) {
       try {
         let result;
         if (msg.method === 'initialize') {
-          result = { protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'supercollab', version: VERSION } };
+          const active = activationFor(config);
+          result = {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {}, prompts: {} },
+            serverInfo: { name: 'supercollab', version: VERSION },
+            instructions: agentInstructions(active),
+          };
         } else if (msg.method === 'tools/list') {
           result = { tools: mcpTools() };
         } else if (msg.method === 'tools/call') {
           const data = await callTool(config, msg.params.name, msg.params.arguments || {});
           result = { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        } else if (msg.method === 'prompts/list') {
+          result = { prompts: mcpPrompts(config).map(({ messages, ...p }) => p) };
+        } else if (msg.method === 'prompts/get') {
+          const prompt = mcpPrompts(config).find((p) => p.name === msg.params.name);
+          if (!prompt) throw new Error(`unknown prompt: ${msg.params.name}`);
+          result = { description: prompt.description, messages: prompt.messages };
         } else if (msg.method && msg.method.startsWith('notifications/')) {
           continue;
         } else {
@@ -617,12 +863,11 @@ async function main() {
   if (opts.help || positionals.length === 0) { printHelp(); return; }
   const [cmd, sub] = positionals;
   const file = configPath(opts);
-  const config = loadConfig(file);
+  const config = attachRuntimeConfig(loadConfig(file), file);
   config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
 
-  if (cmd === 'register') return doRegister(opts);
-  if (cmd === 'login') return doLogin(opts);
-  if (cmd === 'menu') return runMenu(opts);
+  if (cmd === 'register') return console.log(JSON.stringify(await doRegister(config, file, opts), null, 2));
+  if (cmd === 'login') return console.log(JSON.stringify(await doLogin(config, file, opts), null, 2));
   if (cmd === 'whoami') return console.log(JSON.stringify(await api(config, 'GET', '/v1/me'), null, 2));
   if (cmd === 'config' && sub === 'path') return console.log(file);
   if (cmd === 'agent' && sub === 'register') {
@@ -630,30 +875,29 @@ async function main() {
     saveConfig(config, file);
     return console.log(JSON.stringify({ ok: true, agent_id: data.agent_id, fingerprint: data.fingerprint, config: file }, null, 2));
   }
-  if (cmd === 'mcp' && sub === 'stdio') return runMcp(opts);
-  if (cmd === 'mcp' && sub === 'print-config') return printCodexConfig(opts);
-  if (cmd === 'session') {
-    if (sub === 'list') return console.log(JSON.stringify(await api(config, 'GET', '/v1/agent-sessions', undefined, config.userToken), null, 2));
-    if (sub === 'revoke') return console.log(JSON.stringify(await revokeSession(config, file, requireValue(opts, 'session')), null, 2));
+  if (cmd === 'room') {
+    if (sub === 'list') return console.log(JSON.stringify(await apiAsAgent(config, 'GET', '/v1/rooms'), null, 2));
+    if (sub === 'create') return console.log(JSON.stringify(await doRoomCreate(config, file, opts), null, 2));
+    if (sub === 'invite') return console.log(JSON.stringify(await doRoomInvite(config, opts), null, 2));
+    if (sub === 'invites') return console.log(JSON.stringify(await apiAsAgent(config, 'GET', `/v1/rooms/${requireValue(opts, 'room')}/invites`), null, 2));
+    if (sub === 'join') return console.log(JSON.stringify(await doRoomJoin(config, file, opts), null, 2));
+    if (sub === 'key') return console.log(ensureRoomKey(config, requireValue(opts, 'room')));
   }
-  if (cmd === 'workspace') {
-    if (sub === 'list') return console.log(JSON.stringify(await callTool(config, 'workspace_list', {}), null, 2));
-    if (sub === 'create') return console.log(JSON.stringify(await callTool(config, 'workspace_create', { title: requireValue(opts, 'title'), goal: requireValue(opts, 'goal'), slug: opts.slug }), null, 2));
-    if (sub === 'invite') return console.log(JSON.stringify(await callTool(config, 'workspace_invite', { workspace_id: requireValue(opts, 'workspace'), role: opts.role || 'member', ttl_seconds: opts.ttl || 86400 }), null, 2));
-    if (sub === 'invites') return console.log(JSON.stringify(await apiAsAgent(config, 'GET', `/v1/workspaces/${requireValue(opts, 'workspace')}/invites`), null, 2));
-    if (sub === 'invite-revoke') return console.log(JSON.stringify(await apiAsAgent(config, 'DELETE', `/v1/workspaces/${requireValue(opts, 'workspace')}/invites/${requireValue(opts, 'invite')}`), null, 2));
-    if (sub === 'join') return console.log(JSON.stringify(await callTool(config, 'workspace_join', { invite_token: requireValue(opts, 'invite') }), null, 2));
-    if (sub === 'message') return console.log(JSON.stringify(await callTool(config, 'workspace_message_send', { workspace_id: requireValue(opts, 'workspace'), text: requireValue(opts, 'text') }), null, 2));
-    if (sub === 'messages') return console.log(JSON.stringify(await callTool(config, 'workspace_messages_read', { workspace_id: requireValue(opts, 'workspace'), limit: opts.limit || 20 }), null, 2));
-    if (sub === 'search') return console.log(JSON.stringify(await callTool(config, 'workspace_memory_search', { workspace_id: requireValue(opts, 'workspace'), query: requireValue(opts, 'query'), limit: opts.limit || 8 }), null, 2));
-    if (sub === 'write') return console.log(JSON.stringify(await callTool(config, 'workspace_file_write', { workspace_id: requireValue(opts, 'workspace'), path: requireValue(opts, 'path'), content: requireValue(opts, 'content'), commit_message: opts.message }), null, 2));
-    if (sub === 'read') return console.log(JSON.stringify(await callTool(config, 'workspace_file_read', { workspace_id: requireValue(opts, 'workspace'), path: requireValue(opts, 'path') }), null, 2));
-    if (sub === 'git') return console.log(JSON.stringify(await callTool(config, 'workspace_git_status', { workspace_id: requireValue(opts, 'workspace') }), null, 2));
+  if (cmd === 'chat') {
+    if (sub === 'send') return console.log(JSON.stringify(await doChatSend(config, file, opts), null, 2));
+    if (sub === 'read') return console.log(JSON.stringify(await doChatRead(config, file, opts), null, 2));
+    if (sub === 'search') return console.log(JSON.stringify(await doChatSearch(config, file, opts), null, 2));
   }
-  if (cmd === 'heartbeat') {
-    if (sub === 'set') return console.log(JSON.stringify(await callTool(config, 'workspace_heartbeat_set', { workspace_id: requireValue(opts, 'workspace'), prompt: requireValue(opts, 'prompt'), interval_seconds: opts.interval || 900, enabled: opts.enabled !== 'false' }), null, 2));
-    if (sub === 'tick') return console.log(JSON.stringify(await callTool(config, 'workspace_heartbeat_tick', { workspace_id: requireValue(opts, 'workspace') }), null, 2));
+  if (cmd === 'sync') return console.log(JSON.stringify(await syncRoom(config, file, requireValue(opts, 'room')), null, 2));
+  if (cmd === 'activate') return console.log(JSON.stringify(activate(config, file, opts), null, 2));
+  if (cmd === 'deactivate') return console.log(JSON.stringify(deactivate(config, file, opts), null, 2));
+  if (cmd === 'active') return console.log(JSON.stringify(await activeStatus(config, file, opts), null, 2));
+  if (cmd === 'session') {
+    if (sub === 'list') return console.log(JSON.stringify(await api(config, 'GET', '/v1/agent-sessions', undefined, config.userToken), null, 2));
+    if (sub === 'revoke') return console.log(JSON.stringify(await api(config, 'DELETE', `/v1/agent-sessions/${requireValue(opts, 'session')}`, undefined, config.userToken), null, 2));
   }
+  if (cmd === 'mcp' && sub === 'stdio') return runMcp(opts);
+  if (cmd === 'mcp' && sub === 'print-config') return printCodexConfig(opts);
   throw new Error(`unknown command: ${positionals.join(' ')}`);
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@supercollab/cli",
-  "version": "0.1.3",
-  "description": "SuperCollab CLI and MCP bridge for secure agent collaboration workspaces.",
+  "version": "0.4.0",
+  "description": "SuperCollab CLI and MCP bridge for encrypted local-search agent group chat.",
   "type": "module",
   "bin": {
     "supercollab": "./bin/supercollab.js"
@@ -13,11 +13,14 @@
   "engines": {
     "node": ">=20"
   },
+  "dependencies": {
+    "sql.js": "^1.14.1"
+  },
   "keywords": [
     "mcp",
     "agents",
+    "chat",
     "collaboration",
-    "workspace",
     "supercollab"
   ],
   "license": "UNLICENSED",