bertrand 0.17.0 → 0.19.0

package/dist/bertrand.js

@@ -23,22 +23,509 @@ var BERTRAND_DIR = ".bertrand", paths;
 var init_paths = __esm(() => {
   paths = {
     root: join(homedir(), BERTRAND_DIR),
-    db: join(homedir(), BERTRAND_DIR, "bertrand.db"),
     hooks: join(homedir(), BERTRAND_DIR, "hooks"),
-    sessions: join(homedir(), BERTRAND_DIR, "sessions")
+    sessions: join(homedir(), BERTRAND_DIR, "sessions"),
+    db: join(homedir(), BERTRAND_DIR, "bertrand.db"),
+    syncEnv: join(homedir(), BERTRAND_DIR, "sync.env")
+  };
+});
+
+// src/lib/projects/registry.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { randomBytes } from "crypto";
+import { join as join2 } from "path";
+function _getRegistryDir() {
+  return _registryDir;
+}
+function registryPath() {
+  return join2(_registryDir, "projects.json");
+}
+function projectsDir() {
+  return join2(_registryDir, "projects");
+}
+function readRegistry() {
+  const path = registryPath();
+  if (!existsSync(path))
+    return null;
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isRegistry(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeRegistry(registry) {
+  const path = registryPath();
+  mkdirSync(_registryDir, { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${process.hrtime.bigint()}-${randomBytes(4).toString("hex")}`;
+  writeFileSync(tmp, JSON.stringify(registry, null, 2) + `
+`);
+  renameSync(tmp, path);
+}
+function recoverFromDisk() {
+  const dir = projectsDir();
+  if (!existsSync(dir))
+    return null;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  const projects = [];
+  for (const slug of entries) {
+    const subdir = join2(dir, slug);
+    let mtime;
+    try {
+      const s = statSync(subdir);
+      if (!s.isDirectory())
+        continue;
+      mtime = new Date(s.mtimeMs);
+    } catch {
+      continue;
+    }
+    if (!existsSync(join2(subdir, "bertrand.db")))
+      continue;
+    projects.push({
+      slug,
+      name: slug,
+      createdAt: mtime.toISOString(),
+      lastUsedAt: mtime.toISOString()
+    });
+  }
+  if (projects.length === 0)
+    return null;
+  projects.sort((a, b) => a.slug.localeCompare(b.slug));
+  const envSlug = process.env.BERTRAND_PROJECT;
+  const hasEnv = !!envSlug && projects.some((p) => p.slug === envSlug);
+  const hasDefault = projects.some((p) => p.slug === DEFAULT_PROJECT_SLUG);
+  const activeProjectSlug = hasEnv ? envSlug : hasDefault ? DEFAULT_PROJECT_SLUG : projects[0].slug;
+  return { activeProjectSlug, projects };
+}
+function loadRegistry() {
+  return readRegistry() ?? recoverFromDisk();
+}
+function listProjects() {
+  return loadRegistry()?.projects ?? [];
+}
+function getActiveProjectSlug() {
+  return loadRegistry()?.activeProjectSlug ?? DEFAULT_PROJECT_SLUG;
+}
+function projectExists(slug) {
+  return listProjects().some((p) => p.slug === slug);
+}
+function setActiveProjectSlug(slug) {
+  const registry = loadRegistry();
+  if (!registry) {
+    throw new Error(`No registry to update \u2014 create a project first (no ${registryPath()} and no ${projectsDir()}/* to recover from)`);
+  }
+  if (!registry.projects.some((p) => p.slug === slug)) {
+    throw new Error(`Unknown project slug "${slug}"`);
+  }
+  registry.activeProjectSlug = slug;
+  const idx = registry.projects.findIndex((p) => p.slug === slug);
+  if (idx !== -1) {
+    registry.projects[idx].lastUsedAt = new Date().toISOString();
+  }
+  writeRegistry(registry);
+}
+function registerProject(opts) {
+  const registry = loadRegistry() ?? {
+    activeProjectSlug: opts.slug,
+    projects: []
+  };
+  if (registry.projects.some((p) => p.slug === opts.slug)) {
+    throw new Error(`Project "${opts.slug}" already exists`);
+  }
+  const now = new Date().toISOString();
+  const entry = {
+    slug: opts.slug,
+    name: opts.name,
+    color: opts.color,
+    createdAt: now,
+    lastUsedAt: now
+  };
+  registry.projects.push(entry);
+  writeRegistry(registry);
+  return entry;
+}
+function renameProject(slug, newName) {
+  const registry = loadRegistry();
+  if (!registry) {
+    throw new Error(`No registry to update \u2014 create a project first`);
+  }
+  const entry = registry.projects.find((p) => p.slug === slug);
+  if (!entry) {
+    throw new Error(`Unknown project slug "${slug}"`);
+  }
+  entry.name = newName;
+  writeRegistry(registry);
+}
+function removeProject(slug) {
+  const registry = loadRegistry();
+  if (!registry)
+    return;
+  registry.projects = registry.projects.filter((p) => p.slug !== slug);
+  if (registry.activeProjectSlug === slug) {
+    const survivor = [...registry.projects].sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt))[0];
+    registry.activeProjectSlug = survivor?.slug ?? DEFAULT_PROJECT_SLUG;
+  }
+  writeRegistry(registry);
+}
+function isRegistry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const r = value;
+  if (typeof r.activeProjectSlug !== "string")
+    return false;
+  if (!Array.isArray(r.projects))
+    return false;
+  return r.projects.every((p) => {
+    if (typeof p !== "object" || p === null)
+      return false;
+    const e = p;
+    return typeof e.slug === "string" && typeof e.name === "string" && typeof e.createdAt === "string" && typeof e.lastUsedAt === "string";
+  });
+}
+var DEFAULT_PROJECT_SLUG = "default", _registryDir;
+var init_registry = __esm(() => {
+  init_paths();
+  _registryDir = paths.root;
+});
+
+// src/lib/projects/paths.ts
+import { join as join3 } from "path";
+function projectPaths(slug) {
+  const root = join3(_getRegistryDir(), "projects", slug);
+  return {
+    root,
+    db: join3(root, "bertrand.db"),
+    syncEnv: join3(root, "sync.env"),
+    snapshots: join3(root, "snapshots")
   };
+}
+var init_paths2 = __esm(() => {
+  init_registry();
+});
+
+// src/lib/projects/resolve.ts
+function resolveActiveProject() {
+  if (_cached)
+    return _cached;
+  const envSlug = process.env.BERTRAND_PROJECT;
+  let slug;
+  if (envSlug && envSlug.trim()) {
+    slug = envSlug.trim();
+  } else {
+    slug = getActiveProjectSlug();
+  }
+  const entry = listProjects().find((p) => p.slug === slug);
+  const name = entry?.name ?? slug;
+  _cached = { slug, name, ...projectPaths(slug) };
+  return _cached;
+}
+function _resetActiveProjectCache() {
+  _cached = null;
+}
+var _cached = null;
+var init_resolve = __esm(() => {
+  init_registry();
+  init_paths2();
+});
+
+// src/lib/lsof.ts
+import { execFileSync } from "child_process";
+function findHolders(path) {
+  try {
+    const out = execFileSync("lsof", ["-F", "pcn", path], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const holders = [];
+    let pid = 0;
+    let command = "";
+    for (const line of out.split(`
+`)) {
+      if (line.startsWith("p"))
+        pid = Number(line.slice(1));
+      else if (line.startsWith("c"))
+        command = line.slice(1);
+      else if (line.startsWith("n")) {
+        if (pid && pid !== process.pid && command) {
+          holders.push({ pid, command });
+        }
+      }
+    }
+    return holders;
+  } catch {
+    return [];
+  }
+}
+var init_lsof = () => {};
+
+// src/lib/projects/migrate-layout.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "fs";
+import { join as join4 } from "path";
+function migrateLegacyLayout() {
+  const root = _getRegistryDir();
+  const registryFile = join4(root, "projects.json");
+  const projectsDir2 = join4(root, "projects");
+  if (existsSync2(registryFile)) {
+    return { migrated: false, reason: "already-migrated" };
+  }
+  if (existsSync2(projectsDir2)) {
+    return { migrated: false, reason: "already-migrated" };
+  }
+  const legacyDb = join4(root, "bertrand.db");
+  const legacySyncEnv = join4(root, "sync.env");
+  if (!existsSync2(legacyDb) && !existsSync2(legacySyncEnv)) {
+    return { migrated: false, reason: "fresh-install" };
+  }
+  if (existsSync2(legacyDb)) {
+    const holders = findHolders(legacyDb);
+    if (holders.length > 0) {
+      return { migrated: false, reason: "db-held", holders };
+    }
+  }
+  const destPaths = projectPaths(DEFAULT_PROJECT_SLUG);
+  mkdirSync2(destPaths.root, { recursive: true });
+  const moved = [];
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const src = legacyDb + suffix;
+    if (!existsSync2(src))
+      continue;
+    const dst = destPaths.db + suffix;
+    renameSync2(src, dst);
+    moved.push(`bertrand.db${suffix}`);
+  }
+  if (existsSync2(legacySyncEnv)) {
+    renameSync2(legacySyncEnv, destPaths.syncEnv);
+    moved.push("sync.env");
+  }
+  const now = new Date().toISOString();
+  writeRegistry({
+    activeProjectSlug: DEFAULT_PROJECT_SLUG,
+    projects: [
+      {
+        slug: DEFAULT_PROJECT_SLUG,
+        name: "Default",
+        createdAt: now,
+        lastUsedAt: now
+      }
+    ]
+  });
+  _resetActiveProjectCache();
+  return { migrated: true, moved };
+}
+var init_migrate_layout = __esm(() => {
+  init_lsof();
+  init_registry();
+  init_paths2();
+  init_resolve();
+});
+
+// src/sync/config.ts
+import {
+  readFileSync as readFileSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2,
+  chmodSync,
+  existsSync as existsSync3
+} from "fs";
+function parseEnv(contents) {
+  const out = {};
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const eq = line.indexOf("=");
+    if (eq === -1)
+      continue;
+    const key = line.slice(0, eq).trim();
+    if (!KEYS.includes(key))
+      continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function defaultPath() {
+  return resolveActiveProject().syncEnv;
+}
+function hasSyncConfig(syncEnvPath) {
+  return existsSync3(syncEnvPath ?? defaultPath());
+}
+function loadSyncConfig(syncEnvPath) {
+  const path = syncEnvPath ?? defaultPath();
+  if (!existsSync3(path))
+    return null;
+  const mode = statSync2(path).mode & 511;
+  if (mode & 63) {
+    console.warn(`warning: ${path} was mode 0${mode.toString(8)} (should be 0600). Tightening to 0600.`);
+    try {
+      chmodSync(path, 384);
+    } catch (e) {
+      console.warn(`failed to chmod 0600: ${e instanceof Error ? e.message : String(e)}. Fix manually.`);
+    }
+  }
+  const env = parseEnv(readFileSync2(path, "utf8"));
+  if (!env.SUPABASE_URL || !env.SUPABASE_SERVICE_KEY || !env.BERTRAND_SYNC_BUCKET || !env.BERTRAND_ENCRYPTION_KEY) {
+    return null;
+  }
+  return {
+    supabaseUrl: env.SUPABASE_URL,
+    supabaseServiceKey: env.SUPABASE_SERVICE_KEY,
+    bucket: env.BERTRAND_SYNC_BUCKET,
+    objectKey: env.BERTRAND_SYNC_OBJECT || "bertrand.db.enc",
+    encryptionKey: env.BERTRAND_ENCRYPTION_KEY,
+    clientName: env.BERTRAND_CLIENT_NAME || `bertrand-${process.platform}-${process.pid}`
+  };
+}
+function saveSyncConfig(cfg, syncEnvPath) {
+  const path = syncEnvPath ?? defaultPath();
+  const lines = [
+    "# bertrand sync configuration",
+    "# Created by `bertrand sync onboard`. chmod 600.",
+    "#",
+    "# SUPABASE_SERVICE_KEY has read+write access to your storage bucket.",
+    "# Treat it like an SSH private key. Do not commit. Do not share.",
+    "#",
+    "# BERTRAND_ENCRYPTION_KEY is the AES-256-GCM key used to encrypt the DB",
+    "# locally before upload. Without it the uploaded blob can't be decrypted.",
+    "# Use the SAME key on every machine that should be able to pull this DB.",
+    `SUPABASE_URL=${cfg.supabaseUrl}`,
+    `SUPABASE_SERVICE_KEY=${cfg.supabaseServiceKey}`,
+    `BERTRAND_SYNC_BUCKET=${cfg.bucket}`,
+    `BERTRAND_SYNC_OBJECT=${cfg.objectKey}`,
+    `BERTRAND_ENCRYPTION_KEY=${cfg.encryptionKey}`,
+    `BERTRAND_CLIENT_NAME=${cfg.clientName}`,
+    ""
+  ];
+  writeFileSync2(path, lines.join(`
+`), { mode: 384 });
+  chmodSync(path, 384);
+}
+var KEYS;
+var init_config = __esm(() => {
+  init_resolve();
+  KEYS = [
+    "SUPABASE_URL",
+    "SUPABASE_SERVICE_KEY",
+    "BERTRAND_SYNC_BUCKET",
+    "BERTRAND_SYNC_OBJECT",
+    "BERTRAND_ENCRYPTION_KEY",
+    "BERTRAND_CLIENT_NAME"
+  ];
+});
+
+// src/lib/config.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+function configPath() {
+  return join5(_getRegistryDir(), "config.json");
+}
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync3(configPath(), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  mkdirSync3(_getRegistryDir(), { recursive: true });
+  writeFileSync3(configPath(), JSON.stringify(config, null, 2) + `
+`);
+}
+function patchConfig(patch) {
+  const current = readConfig() ?? {};
+  const next = deepMerge(current, patch);
+  writeConfig(next);
+  return next;
+}
+function deepMerge(base, patch) {
+  const out = { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    const existing = out[k];
+    if (isPlainObject(existing) && isPlainObject(v)) {
+      out[k] = deepMerge(existing, v);
+    } else if (v !== undefined) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isSyncEnabled() {
+  return readConfig()?.sync?.enabled === true;
+}
+var init_config2 = __esm(() => {
+  init_registry();
+});
+
+// src/sync/trigger.ts
+import { spawn } from "child_process";
+function spawnSync(op) {
+  if (!isSyncEnabled() || !hasSyncConfig())
+    return;
+  const bin = process.argv[1] && process.argv[1].endsWith(".ts") ? process.execPath : "bertrand";
+  const args = process.argv[1] && process.argv[1].endsWith(".ts") ? ["run", process.argv[1], "sync", op] : ["sync", op];
+  const child = spawn(bin, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function triggerBackgroundPull() {
+  spawnSync("pull");
+}
+function triggerBackgroundPush() {
+  spawnSync("push");
+}
+var init_trigger = __esm(() => {
+  init_config();
+  init_config2();
 });
 
 // src/cli/router.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync4 } from "fs";
 function register(name, handler) {
   commands.set(name, handler);
 }
 function alias(from, to) {
   aliases.set(from, to);
 }
+function migrateOrAbort() {
+  const result = migrateLegacyLayout();
+  if (result.migrated) {
+    const fileList = result.moved.join(", ");
+    console.log(`Migrated to per-project layout (moved: ${fileList}). Active project: ${DEFAULT_PROJECT_SLUG}.`);
+    return;
+  }
+  if (!result.migrated && result.reason === "db-held") {
+    const procs = result.holders.map((h) => `${h.command}(${h.pid})`).join(", ");
+    console.error(`Cannot migrate to per-project layout: legacy database is held by ${procs}.
+` + `Close all active bertrand sessions and try again.`);
+    process.exit(1);
+  }
+}
 async function autoInitIfFirstRun() {
-  if (existsSync(paths.db))
+  if (existsSync4(resolveActiveProject().db))
     return;
   const init = commands.get("init");
   if (!init)
@@ -55,8 +542,12 @@ async function autoInitIfFirstRun() {
 async function route(argv) {
   const args = argv.slice(2);
   const command = args[0];
+  if (!command || !HOOK_COMMANDS.has(command)) {
+    migrateOrAbort();
+  }
   if (!command) {
     await autoInitIfFirstRun();
+    triggerBackgroundPull();
     const handler2 = commands.get("launch");
     if (!handler2)
       throw new Error("No launch command registered");
@@ -90,15 +581,28 @@ Usage:
   bertrand log <session>    View session log
   bertrand stats <session>  Session statistics
   bertrand archive <name>   Archive/unarchive a session
+  bertrand project <op>     list|create|switch|current|rename|remove (see: bertrand project --help)
   bertrand update           Hook-facing state writer (internal)
   bertrand serve            Start dashboard HTTP server
+  bertrand sync <op>        push|pull|status|onboard (see: bertrand sync --help)
 `.trim());
 }
-var commands, aliases;
+var commands, aliases, HOOK_COMMANDS;
 var init_router = __esm(() => {
-  init_paths();
+  init_resolve();
+  init_migrate_layout();
+  init_registry();
+  init_trigger();
   commands = new Map;
   aliases = new Map;
+  HOOK_COMMANDS = new Set([
+    "update",
+    "snapshot",
+    "recap-thinking",
+    "assistant-message",
+    "notify",
+    "badge"
+  ]);
 });
 
 // src/db/schema.ts
@@ -109,17 +613,17 @@ __export(exports_schema, {
   sessionStats: () => sessionStats,
   sessionLabels: () => sessionLabels,
   labels: () => labels,
-  groups: () => groups,
   events: () => events,
-  conversations: () => conversations
+  conversations: () => conversations,
+  categories: () => categories
 });
 import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
 import { sql } from "drizzle-orm";
-var groups, labels, sessions, sessionLabels, conversations, events, worktreeAssociations, sessionStats;
+var categories, labels, sessions, sessionLabels, conversations, events, worktreeAssociations, sessionStats;
 var init_schema = __esm(() => {
-  groups = sqliteTable("groups", {
+  categories = sqliteTable("categories", {
     id: text("id").primaryKey(),
-    parentId: text("parent_id").references(() => groups.id, {
+    parentId: text("parent_id").references(() => categories.id, {
       onDelete: "cascade"
     }),
     slug: text("slug").notNull(),
@@ -129,8 +633,8 @@ var init_schema = __esm(() => {
     color: text("color"),
     createdAt: text("created_at").notNull().default(sql`(datetime('now'))`)
   }, (t) => [
-    uniqueIndex("groups_parent_slug").on(t.parentId, t.slug),
-    index("groups_path").on(t.path)
+    uniqueIndex("categories_parent_slug").on(t.parentId, t.slug),
+    index("categories_path").on(t.path)
   ]);
   labels = sqliteTable("labels", {
     id: text("id").primaryKey(),
@@ -140,7 +644,7 @@ var init_schema = __esm(() => {
   });
   sessions = sqliteTable("sessions", {
     id: text("id").primaryKey(),
-    groupId: text("group_id").notNull().references(() => groups.id, { onDelete: "cascade" }),
+    categoryId: text("category_id").notNull().references(() => categories.id, { onDelete: "cascade" }),
     slug: text("slug").notNull(),
     name: text("name").notNull(),
     status: text("status", {
@@ -153,7 +657,7 @@ var init_schema = __esm(() => {
     createdAt: text("created_at").notNull().default(sql`(datetime('now'))`),
     updatedAt: text("updated_at").notNull().default(sql`(datetime('now'))`)
   }, (t) => [
-    uniqueIndex("sessions_group_slug").on(t.groupId, t.slug),
+    uniqueIndex("sessions_category_slug").on(t.categoryId, t.slug),
     index("sessions_status").on(t.status),
     index("sessions_started").on(t.startedAt)
   ]);
@@ -219,25 +723,61 @@ var init_schema = __esm(() => {
 // src/db/client.ts
 import { Database } from "bun:sqlite";
 import { drizzle } from "drizzle-orm/bun-sqlite";
-import { mkdirSync } from "fs";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
+import { mkdirSync as mkdirSync4 } from "fs";
 import { dirname } from "path";
 function getDb() {
-  if (_db)
-    return _db;
-  mkdirSync(dirname(paths.db), { recursive: true });
-  const sqlite = new Database(paths.db);
+  if (_testDb)
+    return _testDb;
+  return openDb(resolveActiveProject().db);
+}
+function getDbForProject(slug) {
+  if (_testDb)
+    return _testDb;
+  return openDb(projectPaths(slug).db);
+}
+function invalidateDbCache(slug) {
+  if (!slug) {
+    _cache.clear();
+    _migrated.clear();
+    return;
+  }
+  const dbPath = projectPaths(slug).db;
+  _cache.delete(dbPath);
+  _migrated.delete(dbPath);
+}
+function openDb(dbPath) {
+  const cached = _cache.get(dbPath);
+  if (cached)
+    return cached;
+  mkdirSync4(dirname(dbPath), { recursive: true });
+  const sqlite = new Database(dbPath);
   sqlite.exec("PRAGMA journal_mode = WAL");
   sqlite.exec("PRAGMA foreign_keys = ON");
   sqlite.exec("PRAGMA synchronous = NORMAL");
   sqlite.exec("PRAGMA cache_size = -8000");
   sqlite.exec("PRAGMA temp_store = MEMORY");
-  _db = drizzle(sqlite, { schema: exports_schema });
-  return _db;
+  const db = drizzle(sqlite, { schema: exports_schema });
+  if (!_migrated.has(dbPath)) {
+    try {
+      migrate(db, { migrationsFolder: MIGRATIONS_FOLDER });
+    } catch (err) {
+      sqlite.close();
+      throw err;
+    }
+    _migrated.add(dbPath);
+  }
+  _cache.set(dbPath, db);
+  return db;
 }
-var _db = null;
+var MIGRATIONS_FOLDER, _cache, _migrated, _testDb = null;
 var init_client = __esm(() => {
-  init_paths();
+  init_resolve();
+  init_paths2();
   init_schema();
+  MIGRATIONS_FOLDER = import.meta.dir + "/migrations";
+  _cache = new Map;
+  _migrated = new Set;
 });
 
 // src/lib/id.ts
@@ -257,18 +797,18 @@ function createSession(opts) {
 function getSession(id) {
   return getDb().select().from(sessions).where(eq(sessions.id, id)).get();
 }
-function getSessionByGroupSlug(groupId, slug) {
-  return getDb().select().from(sessions).where(and(eq(sessions.groupId, groupId), eq(sessions.slug, slug))).get();
+function getSessionByCategorySlug(categoryId, slug) {
+  return getDb().select().from(sessions).where(and(eq(sessions.categoryId, categoryId), eq(sessions.slug, slug))).get();
 }
-function getSessionsByGroup(groupId) {
-  return getDb().select().from(sessions).where(eq(sessions.groupId, groupId)).all();
+function getSessionsByCategory(categoryId) {
+  return getDb().select().from(sessions).where(eq(sessions.categoryId, categoryId)).all();
 }
 function getActiveSessions() {
-  return getDb().select({ session: sessions, groupPath: groups.path }).from(sessions).innerJoin(groups, eq(sessions.groupId, groups.id)).where(inArray(sessions.status, ["active", "waiting"])).all();
+  return getDb().select({ session: sessions, categoryPath: categories.path }).from(sessions).innerJoin(categories, eq(sessions.categoryId, categories.id)).where(inArray(sessions.status, ["active", "waiting"])).all();
 }
 function getAllSessions(opts) {
   const db = getDb();
-  const query = db.select({ session: sessions, groupPath: groups.path }).from(sessions).innerJoin(groups, eq(sessions.groupId, groups.id));
+  const query = db.select({ session: sessions, categoryPath: categories.path }).from(sessions).innerJoin(categories, eq(sessions.categoryId, categories.id));
   if (opts?.excludeArchived) {
     return query.where(inArray(sessions.status, [
       "active",
@@ -405,12 +945,23 @@ var init_conversations = __esm(() => {
 
 // src/cli/commands/update.ts
 var exports_update = {};
+__export(exports_update, {
+  shouldIgnoreStatusFlip: () => shouldIgnoreStatusFlip
+});
+function shouldIgnoreStatusFlip(newStatus, sessionPid) {
+  if (!newStatus)
+    return false;
+  if (newStatus !== "active" && newStatus !== "waiting")
+    return false;
+  return sessionPid === null;
+}
 var EVENT_STATUS_MAP;
 var init_update = __esm(() => {
   init_router();
   init_sessions();
   init_events();
   init_conversations();
+  init_trigger();
   EVENT_STATUS_MAP = {
     "session.waiting": "waiting",
     "session.answered": "active",
@@ -454,6 +1005,7 @@ var init_update = __esm(() => {
     if (newStatus && newStatus === session.status) {
       return;
     }
+    const ignoreStatusFlip = shouldIgnoreStatusFlip(newStatus, session.pid);
     let meta;
     if (metaJson) {
       try {
@@ -474,17 +1026,20 @@ var init_update = __esm(() => {
       summary: summaryArg || meta?.question || joinedAnswers || undefined,
       meta
     });
-    if (newStatus) {
+    if (newStatus && !ignoreStatusFlip) {
       updateSessionStatus(sessionId, newStatus);
     }
     if (event === "session.waiting" && conversationId && meta?.question) {
       updateLastQuestion(conversationId, meta.question);
     }
+    if (event === "session.end") {
+      triggerBackgroundPush();
+    }
   });
 });
 
 // src/lib/transcript.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 function getContextWindowSize(model) {
   for (const [prefix, size] of Object.entries(CONTEXT_WINDOW_SIZES)) {
     if (model.startsWith(prefix))
@@ -493,9 +1048,9 @@ function getContextWindowSize(model) {
   return 200000;
 }
 function getLatestAssistantTurn(filePath) {
-  if (!existsSync2(filePath))
+  if (!existsSync5(filePath))
     return null;
-  const text2 = readFileSync(filePath, "utf-8");
+  const text2 = readFileSync4(filePath, "utf-8");
   const lines = text2.split(`
 `);
   const assistantEntries = [];
@@ -553,9 +1108,9 @@ function getLatestAssistantTurn(filePath) {
   };
 }
 function getContextSnapshot(filePath) {
-  if (!existsSync2(filePath))
+  if (!existsSync5(filePath))
     return null;
-  const text2 = readFileSync(filePath, "utf-8");
+  const text2 = readFileSync4(filePath, "utf-8");
   const lines = text2.split(`
 `);
   for (let i = lines.length - 1;i >= 0; i--) {
@@ -822,8 +1377,8 @@ class NoopAdapter {
 }
 
 // src/terminal/index.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 function getTerminalAdapter() {
   if (cachedAdapter)
     return cachedAdapter;
@@ -842,7 +1397,7 @@ function getTerminalAdapter() {
 }
 function readConfigTerminal() {
   try {
-    const config = JSON.parse(readFileSync2(join2(paths.root, "config.json"), "utf-8"));
+    const config = JSON.parse(readFileSync5(join6(paths.root, "config.json"), "utf-8"));
     return config.terminal ?? null;
   } catch {
     return null;
@@ -1181,7 +1736,7 @@ function archiveAllPaused() {
   const archived = [];
   for (const row of paused) {
     const updated = updateSessionStatus(row.session.id, "archived");
-    archived.push({ session: updated, groupPath: row.groupPath });
+    archived.push({ session: updated, categoryPath: row.categoryPath });
   }
   return { archived };
 }
@@ -1193,8 +1748,8 @@ var init_session_archive = __esm(() => {
 
 // src/server/index.ts
 import { execFile } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
 function liveStats(sessionId) {
   return {
     sessionId,
@@ -1208,6 +1763,24 @@ function archiveResponse(result) {
   const meta = ARCHIVE_ERROR[result.reason] ?? { status: 400, message: "Operation failed" };
   return Response.json({ error: meta.message, reason: result.reason }, { status: meta.status });
 }
+async function handleSwitchProject(req) {
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+  const slug = body.slug;
+  if (typeof slug !== "string") {
+    return Response.json({ error: "slug must be a string" }, { status: 400 });
+  }
+  if (!projectExists(slug)) {
+    return Response.json({ error: `Unknown project: ${slug}` }, { status: 404 });
+  }
+  setActiveProjectSlug(slug);
+  queueMicrotask(() => process.exit(0));
+  return Response.json({ ok: true, slug, willRestart: true });
+}
 async function handleOpen(req) {
   let body;
   try {
@@ -1247,11 +1820,11 @@ function match(pathname, url) {
 }
 function findDashboardDir() {
   const candidates = [
-    join3(import.meta.dir, "dashboard"),
-    join3(import.meta.dir, "..", "dashboard")
+    join7(import.meta.dir, "dashboard"),
+    join7(import.meta.dir, "..", "dashboard")
   ];
   for (const dir of candidates) {
-    if (existsSync3(join3(dir, "index.html")))
+    if (existsSync6(join7(dir, "index.html")))
       return dir;
   }
   return null;
@@ -1260,13 +1833,13 @@ async function serveDashboard(pathname) {
   if (!DASHBOARD_DIR)
     return null;
   const requested = pathname === "/" ? "/index.html" : pathname;
-  const filePath = join3(DASHBOARD_DIR, requested);
+  const filePath = join7(DASHBOARD_DIR, requested);
   if (!filePath.startsWith(DASHBOARD_DIR))
     return null;
   const file = Bun.file(filePath);
   if (await file.exists())
     return new Response(file);
-  return new Response(Bun.file(join3(DASHBOARD_DIR, "index.html")));
+  return new Response(Bun.file(join7(DASHBOARD_DIR, "index.html")));
 }
 function startServer(port = PORT) {
   const server = Bun.serve({
@@ -1287,6 +1860,11 @@ function startServer(port = PORT) {
         r.headers.set("Access-Control-Allow-Origin", "*");
         return r;
       }
+      if (req.method === "POST" && url.pathname === "/api/active-project") {
+        const r = await handleSwitchProject(req);
+        r.headers.set("Access-Control-Allow-Origin", "*");
+        return r;
+      }
       if (req.method === "POST") {
         const archiveMatch = /^\/api\/sessions\/([^/]+)\/archive$/.exec(url.pathname);
         if (archiveMatch) {
@@ -1349,7 +1927,18 @@ var PORT, listSessions = (_params, url) => {
   return getSessionStats(sessionId) ?? liveStats(sessionId);
 }, getEngagement = ({
   sessionId
-}) => computeEngagementStats(sessionId), listRecaps = () => getLatestRecaps(), routes, ARCHIVE_ERROR, DASHBOARD_DIR;
+}) => computeEngagementStats(sessionId), listRecaps = () => getLatestRecaps(), listAllProjects = () => {
+  const active = resolveActiveProject();
+  return listProjects().map((p) => ({
+    slug: p.slug,
+    name: p.name,
+    active: p.slug === active.slug,
+    lastUsedAt: p.lastUsedAt
+  }));
+}, getActiveProjectMeta = () => {
+  const active = resolveActiveProject();
+  return { slug: active.slug, name: active.name };
+}, routes, ARCHIVE_ERROR, DASHBOARD_DIR;
 var init_server = __esm(() => {
   init_sessions();
   init_events();
@@ -1357,6 +1946,8 @@ var init_server = __esm(() => {
   init_timing();
   init_engagement_stats();
   init_session_archive();
+  init_registry();
+  init_resolve();
   PORT = Number(process.env.BERTRAND_PORT ?? 5200);
   routes = [
     [/^\/api\/sessions$/, listSessions],
@@ -1365,7 +1956,9 @@ var init_server = __esm(() => {
     [/^\/api\/stats$/, listAllStats],
     [/^\/api\/stats\/(?<sessionId>[^/]+)$/, getStatsBySession],
     [/^\/api\/engagement\/(?<sessionId>[^/]+)$/, getEngagement],
-    [/^\/api\/recaps$/, listRecaps]
+    [/^\/api\/recaps$/, listRecaps],
+    [/^\/api\/projects$/, listAllProjects],
+    [/^\/api\/active-project$/, getActiveProjectMeta]
   ];
   ARCHIVE_ERROR = {
     "not-found": { status: 404, message: "Session not found" },
@@ -1380,55 +1973,819 @@ var init_server = __esm(() => {
 var exports_serve = {};
 var init_serve = __esm(() => {
   init_router();
-  init_server();
-  register("serve", async () => {
-    startServer();
-    await new Promise(() => {});
+  init_server();
+  register("serve", async () => {
+    startServer();
+    await new Promise(() => {});
+  });
+});
+
+// src/sync/snapshot.ts
+import { Database as Database2 } from "bun:sqlite";
+import { existsSync as existsSync7, unlinkSync } from "fs";
+function snapshotPathFor(dbPath) {
+  return `${dbPath}.sync-snapshot`;
+}
+function takeSnapshot() {
+  cleanupSnapshot();
+  const dbPath = resolveActiveProject().db;
+  const target = snapshotPathFor(dbPath);
+  const src = new Database2(dbPath, { readonly: true });
+  try {
+    src.exec(`VACUUM INTO '${target.replace(/'/g, "''")}'`);
+  } finally {
+    src.close();
+  }
+  return target;
+}
+function cleanupSnapshot() {
+  const base = snapshotPathFor(resolveActiveProject().db);
+  for (const suffix of SIDECAR_SUFFIXES) {
+    const p = base + suffix;
+    if (existsSync7(p)) {
+      try {
+        unlinkSync(p);
+      } catch {}
+    }
+  }
+}
+var SIDECAR_SUFFIXES;
+var init_snapshot2 = __esm(() => {
+  init_resolve();
+  SIDECAR_SUFFIXES = ["", "-wal", "-shm"];
+});
+
+// src/sync/crypto.ts
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes2 } from "crypto";
+function parseKey(base64Key) {
+  const buf = Buffer.from(base64Key, "base64");
+  if (buf.length !== 32) {
+    throw new Error(`BERTRAND_ENCRYPTION_KEY must decode to 32 bytes (got ${buf.length}). ` + `Generate one with: openssl rand -base64 32`);
+  }
+  return buf;
+}
+function generateKeyBase64() {
+  return randomBytes2(32).toString("base64");
+}
+function encrypt(plaintext, base64Key) {
+  const key = parseKey(base64Key);
+  const iv = randomBytes2(IV_LEN);
+  const cipher = createCipheriv(ALGO, key, iv);
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([MAGIC, iv, ciphertext, tag]);
+}
+function decrypt(blob, base64Key) {
+  if (blob.length < MAGIC.length + IV_LEN + TAG_LEN) {
+    throw new Error("encrypted blob too small to be valid");
+  }
+  if (!blob.subarray(0, MAGIC.length).equals(MAGIC)) {
+    throw new Error("not a bertrand encrypted blob (magic prefix mismatch). " + "Did you upload a plaintext .db file by mistake?");
+  }
+  const key = parseKey(base64Key);
+  const iv = blob.subarray(MAGIC.length, MAGIC.length + IV_LEN);
+  const tag = blob.subarray(blob.length - TAG_LEN);
+  const ciphertext = blob.subarray(MAGIC.length + IV_LEN, blob.length - TAG_LEN);
+  const decipher = createDecipheriv(ALGO, key, iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+var ALGO = "aes-256-gcm", IV_LEN = 12, TAG_LEN = 16, MAGIC;
+var init_crypto = __esm(() => {
+  MAGIC = Buffer.from("BTRD1", "ascii");
+});
+
+// src/sync/engine.ts
+import { createClient } from "@supabase/supabase-js";
+import { readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync3, openSync, writeSync, fsyncSync, closeSync } from "fs";
+import { dirname as dirname2 } from "path";
+function client(cfg) {
+  if (!cfg)
+    return null;
+  return createClient(cfg.supabaseUrl, cfg.supabaseServiceKey, {
+    auth: { persistSession: false, autoRefreshToken: false }
+  });
+}
+async function push() {
+  if (!hasSyncConfig()) {
+    return { ok: false, operation: "push", error: "no sync config \u2014 run `bertrand sync onboard`" };
+  }
+  const cfg = loadSyncConfig();
+  const supabase = client(cfg);
+  if (!cfg || !supabase) {
+    return { ok: false, operation: "push", error: "sync config incomplete" };
+  }
+  const started = performance.now();
+  try {
+    let snapshotPath;
+    try {
+      snapshotPath = takeSnapshot();
+    } catch (e) {
+      return {
+        ok: false,
+        operation: "push",
+        error: `snapshot failed: ${e instanceof Error ? e.message : String(e)}`
+      };
+    }
+    const plaintext = readFileSync6(snapshotPath);
+    const ciphertext = encrypt(plaintext, cfg.encryptionKey);
+    const { error } = await supabase.storage.from(cfg.bucket).upload(cfg.objectKey, ciphertext, {
+      contentType: "application/octet-stream",
+      upsert: true
+    });
+    if (error) {
+      return { ok: false, operation: "push", error: `upload failed: ${error.message}` };
+    }
+    return {
+      ok: true,
+      operation: "push",
+      bytes: ciphertext.length,
+      durationMs: Math.round(performance.now() - started)
+    };
+  } catch (e) {
+    return { ok: false, operation: "push", error: e instanceof Error ? e.message : String(e) };
+  } finally {
+    cleanupSnapshot();
+  }
+}
+async function pull(opts = {}) {
+  if (!hasSyncConfig()) {
+    return { ok: false, operation: "pull", error: "no sync config \u2014 run `bertrand sync onboard`" };
+  }
+  const cfg = loadSyncConfig();
+  const supabase = client(cfg);
+  if (!cfg || !supabase) {
+    return { ok: false, operation: "pull", error: "sync config incomplete" };
+  }
+  const dbPath = resolveActiveProject().db;
+  const holders = findHolders(dbPath);
+  if (holders.length > 0) {
+    const procs = holders.map((h) => `${h.command}(${h.pid})`).join(", ");
+    if (!opts.force) {
+      return {
+        ok: false,
+        operation: "pull",
+        error: `${dbPath} is held by ${procs} \u2014 close active bertrand sessions before pulling, ` + `or pass --force to overwrite anyway (risks corrupting the running session).`
+      };
+    }
+    console.warn(`warning: --force pulling while ${procs} hold ${dbPath}. The running process may crash on next file access.`);
+  }
+  const started = performance.now();
+  try {
+    const { data, error } = await supabase.storage.from(cfg.bucket).download(cfg.objectKey);
+    if (error || !data) {
+      if (error?.message?.toLowerCase().includes("not found")) {
+        return {
+          ok: true,
+          operation: "pull",
+          pulled: false,
+          bytes: 0,
+          durationMs: Math.round(performance.now() - started)
+        };
+      }
+      return { ok: false, operation: "pull", error: `download failed: ${error?.message ?? "no data"}` };
+    }
+    const ciphertext = Buffer.from(await data.arrayBuffer());
+    const plaintext = decrypt(ciphertext, cfg.encryptionKey);
+    const tmp = `${dbPath}.pull-${process.pid}`;
+    const fd = openSync(tmp, "w");
+    try {
+      writeSync(fd, plaintext);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync3(tmp, dbPath);
+    const dirFd = openSync(dirname2(dbPath), "r");
+    try {
+      fsyncSync(dirFd);
+    } finally {
+      closeSync(dirFd);
+    }
+    return {
+      ok: true,
+      operation: "pull",
+      pulled: true,
+      bytes: plaintext.length,
+      durationMs: Math.round(performance.now() - started)
+    };
+  } catch (e) {
+    return { ok: false, operation: "pull", error: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function status() {
+  const cfg = loadSyncConfig();
+  if (!cfg)
+    return { configured: false, local: null, remote: null };
+  const dbPath = resolveActiveProject().db;
+  let local = null;
+  try {
+    const s = statSync3(dbPath);
+    local = { size: s.size, modifiedAt: new Date(s.mtimeMs) };
+  } catch {
+    local = null;
+  }
+  const supabase = client(cfg);
+  let remote = null;
+  if (supabase) {
+    try {
+      const parentPath = cfg.objectKey.includes("/") ? cfg.objectKey.slice(0, cfg.objectKey.lastIndexOf("/")) : "";
+      const fileName = cfg.objectKey.includes("/") ? cfg.objectKey.slice(cfg.objectKey.lastIndexOf("/") + 1) : cfg.objectKey;
+      const { data, error } = await supabase.storage.from(cfg.bucket).list(parentPath, { search: fileName });
+      if (!error && data) {
+        const match2 = data.find((f) => f.name === fileName);
+        if (match2) {
+          remote = {
+            size: match2.metadata?.size ?? 0,
+            modifiedAt: new Date(match2.updated_at ?? match2.created_at ?? Date.now())
+          };
+        }
+      }
+    } catch {}
+  }
+  return { configured: true, local, remote };
+}
+var init_engine = __esm(() => {
+  init_resolve();
+  init_lsof();
+  init_config();
+  init_snapshot2();
+  init_crypto();
+});
+
+// src/sync/invite.ts
+function encodeInvite(cfg, project) {
+  const bundle = {
+    v: VERSION,
+    url: cfg.supabaseUrl,
+    key: cfg.supabaseServiceKey,
+    bucket: cfg.bucket,
+    obj: cfg.objectKey,
+    ek: cfg.encryptionKey,
+    psl: project.slug,
+    pn: project.name
+  };
+  return SCHEME + Buffer.from(JSON.stringify(bundle), "utf8").toString("base64url");
+}
+function isInvite(value) {
+  return typeof value === "string" && value.startsWith(SCHEME);
+}
+function decodeInvite(invite) {
+  if (!invite.startsWith(SCHEME)) {
+    throw new Error(`invite must start with ${SCHEME}`);
+  }
+  const payload = invite.slice(SCHEME.length).trim();
+  let parsed;
+  try {
+    const json = Buffer.from(payload, "base64url").toString("utf8");
+    parsed = JSON.parse(json);
+  } catch {
+    throw new Error("invite is malformed \u2014 could not decode base64/JSON payload");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("invite payload is not a JSON object");
+  }
+  const bundle = parsed;
+  if (bundle.v !== VERSION) {
+    throw new Error(`invite version ${String(bundle.v)} is not supported (expected v${VERSION}). ` + `Both machines must run a per-project-aware bertrand. ` + `Upgrade the source machine and regenerate the invite.`);
+  }
+  for (const field of ["url", "key", "bucket", "obj", "ek", "psl", "pn"]) {
+    if (!bundle[field] || typeof bundle[field] !== "string") {
+      throw new Error(`invite is missing required field: ${field}`);
+    }
+  }
+  return {
+    config: {
+      supabaseUrl: bundle.url,
+      supabaseServiceKey: bundle.key,
+      bucket: bundle.bucket,
+      objectKey: bundle.obj,
+      encryptionKey: bundle.ek
+    },
+    project: {
+      slug: bundle.psl,
+      name: bundle.pn
+    }
+  };
+}
+var SCHEME = "bertrand-sync://", VERSION = 2;
+
+// src/db/migrate.ts
+import { Database as Database3 } from "bun:sqlite";
+import { drizzle as drizzle2 } from "drizzle-orm/bun-sqlite";
+import { migrate as migrate2 } from "drizzle-orm/bun-sqlite/migrator";
+import { mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname3 } from "path";
+function runMigrations(dbPath) {
+  const target = dbPath ?? resolveActiveProject().db;
+  mkdirSync5(dirname3(target), { recursive: true });
+  const sqlite = new Database3(target);
+  sqlite.exec("PRAGMA journal_mode = WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  const db = drizzle2(sqlite);
+  migrate2(db, { migrationsFolder: MIGRATIONS_FOLDER2 });
+  sqlite.close();
+}
+var MIGRATIONS_FOLDER2;
+var init_migrate = __esm(() => {
+  init_resolve();
+  MIGRATIONS_FOLDER2 = import.meta.dir + "/migrations";
+  if (false) {}
+});
+
+// src/lib/projects/create.ts
+import { mkdirSync as mkdirSync6 } from "fs";
+function createProject(opts) {
+  registerProject({ slug: opts.slug, name: opts.name ?? opts.slug });
+  try {
+    const paths2 = projectPaths(opts.slug);
+    mkdirSync6(paths2.root, { recursive: true });
+    runMigrations(paths2.db);
+  } catch (err) {
+    try {
+      removeProject(opts.slug);
+    } catch {}
+    throw err;
+  }
+}
+var init_create = __esm(() => {
+  init_migrate();
+  init_registry();
+  init_paths2();
+});
+
+// src/sync/bootstrap.ts
+import { hostname } from "os";
+async function bootstrapFromInvite(invite) {
+  let decoded;
+  try {
+    decoded = decodeInvite(invite);
+  } catch (e) {
+    return {
+      ok: false,
+      reason: "decode-failed",
+      error: e instanceof Error ? e.message : String(e)
+    };
+  }
+  const { config: cfg, project } = decoded;
+  if (listProjects().some((p) => p.slug === project.slug)) {
+    return {
+      ok: false,
+      reason: "slug-collision",
+      error: `Project "${project.slug}" already exists on this machine. Remove it first (\`bertrand project remove ${project.slug} --purge\`) or rename it before importing.`
+    };
+  }
+  createProject({ slug: project.slug, name: project.name });
+  setActiveProjectSlug(project.slug);
+  _resetActiveProjectCache();
+  resolveActiveProject();
+  saveSyncConfig({ ...cfg, clientName: `bertrand-${hostname()}` });
+  patchConfig({ sync: { enabled: true } });
+  const result = await pull();
+  if (!result.ok) {
+    return {
+      ok: false,
+      reason: "pull-failed",
+      error: result.error
+    };
+  }
+  return {
+    ok: true,
+    project,
+    pulled: result.pulled ?? false,
+    bytes: result.bytes ?? 0,
+    durationMs: result.durationMs ?? 0
+  };
+}
+var init_bootstrap = __esm(() => {
+  init_config();
+  init_engine();
+  init_registry();
+  init_create();
+  init_resolve();
+  init_config2();
+});
+
+// src/lib/format.ts
+function formatDuration(ms) {
+  if (ms < MINUTE)
+    return `${Math.round(ms / SECOND)}s`;
+  const days = Math.floor(ms / DAY);
+  const hours = Math.floor(ms % DAY / HOUR);
+  const minutes = Math.floor(ms % HOUR / MINUTE);
+  if (days > 0)
+    return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+  if (hours > 0)
+    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+  return `${minutes}m`;
+}
+function formatAgo(isoOrDate) {
+  const date = typeof isoOrDate === "string" ? new Date(isoOrDate) : isoOrDate;
+  const ms = Date.now() - date.getTime();
+  if (ms < MINUTE)
+    return "just now";
+  if (ms < HOUR)
+    return `${Math.floor(ms / MINUTE)}m ago`;
+  if (ms < DAY)
+    return `${Math.floor(ms / HOUR)}h ago`;
+  if (ms < 2 * DAY)
+    return "yesterday";
+  if (ms < 7 * DAY)
+    return `${Math.floor(ms / DAY)}d ago`;
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function truncate(text2, maxLen) {
+  if (text2.length <= maxLen)
+    return text2;
+  return text2.slice(0, maxLen - 1) + "\u2026";
+}
+function formatTime(iso, includeDate = false) {
+  const date = new Date(iso);
+  const time = date.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit"
+  });
+  if (!includeDate)
+    return time;
+  const day = date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric"
+  });
+  return `${day} ${time}`;
+}
+var SECOND = 1000, MINUTE, HOUR, DAY;
+var init_format = __esm(() => {
+  MINUTE = 60 * SECOND;
+  HOUR = 60 * MINUTE;
+  DAY = 24 * HOUR;
+});
+
+// src/cli/commands/sync.ts
+var exports_sync = {};
+import { hostname as hostname2 } from "os";
+function printUsage2() {
+  console.log(`
+bertrand sync \u2014 replicate a project's local DB to Supabase Storage (opt-in)
+
+Usage:
+  bertrand sync onboard [--project <slug>]   Interactive setup for a project
+  bertrand sync invite [--project <slug>]    Print a paste-able bundle
+  bertrand sync <bundle>                     Decode bundle, create project, save config, pull
+  bertrand sync push [--project <slug>]      VACUUM \u2192 encrypt \u2192 upload
+  bertrand sync pull [--force] [--project <slug>]
+                                             Download \u2192 decrypt \u2192 atomic-replace
+  bertrand sync status [--project <slug>]    Local + remote object size and timestamps
+  bertrand sync enable [--project <slug>]    Turn auto-triggers on
+  bertrand sync disable [--project <slug>]   Turn auto-triggers off
+
+All subcommands default to the active project. Pass --project to operate
+on a different one without switching active.
+
+Cross-machine setup:
+  Machine A:  bertrand sync invite
+              \u2192 bertrand-sync://eyJ\u2026   (transmit via Signal/iMessage/AirDrop \u2014 sensitive)
+  Machine B:  bertrand sync bertrand-sync://eyJ\u2026
+              \u2192 creates the project, onboards, pulls, ready
+`.trim());
+}
+function abort(reason) {
+  console.error(`Aborted: ${reason}`);
+  process.exit(1);
+}
+function extractProjectFlag(args) {
+  const rest = [];
+  let slug;
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a === "--project") {
+      slug = args[i + 1];
+      i++;
+      continue;
+    }
+    if (a.startsWith("--project=")) {
+      slug = a.slice("--project=".length);
+      continue;
+    }
+    rest.push(a);
+  }
+  return { slug, rest };
+}
+function applyProjectOverride(slug) {
+  if (!slug)
+    return;
+  const known = listProjects().some((p) => p.slug === slug);
+  if (!known) {
+    abort(`Unknown project: ${slug}. Run \`bertrand project list\` to see registered projects.`);
+    return;
+  }
+  process.env.BERTRAND_PROJECT = slug;
+  _resetActiveProjectCache();
+}
+function prompt(label, opts = {}) {
+  const suffix = opts.default ? ` [${opts.default}]` : "";
+  process.stdout.write(`${label}${suffix}: `);
+  return new Promise((resolve) => {
+    let buf = "";
+    const onData = (chunk) => {
+      const s = chunk.toString("utf8");
+      for (const ch of s) {
+        if (ch === `
+` || ch === "\r") {
+          process.stdin.off("data", onData);
+          process.stdin.pause();
+          process.stdout.write(`
+`);
+          return resolve(buf.trim() || opts.default || "");
+        }
+        buf += ch;
+      }
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function runOnboard() {
+  const active = resolveActiveProject();
+  const existing = loadSyncConfig();
+  if (existing) {
+    console.log(`Existing config for project "${active.slug}" at ${active.syncEnv}:`);
+    console.log(`  SUPABASE_URL:           ${existing.supabaseUrl}`);
+    console.log(`  SUPABASE_SERVICE_KEY:   ${existing.supabaseServiceKey.slice(0, 12)}\u2026`);
+    console.log(`  BERTRAND_SYNC_BUCKET:   ${existing.bucket}`);
+    console.log(`  BERTRAND_SYNC_OBJECT:   ${existing.objectKey}`);
+    console.log(`  BERTRAND_ENCRYPTION_KEY: (set, redacted)`);
+    console.log(`  BERTRAND_CLIENT_NAME:   ${existing.clientName}`);
+    console.log(`
+Delete ${active.syncEnv} and re-run to start over.`);
+    return;
+  }
+  console.log(`Bertrand sync setup for project "${active.slug}" (${active.name})
+`);
+  console.log(`In the Supabase dashboard (app.supabase.com):`);
+  console.log(`  1. Create or pick a project`);
+  console.log(`  2. Settings \u2192 General: copy the Project ID (the 20-char lowercase string`);
+  console.log(`     shown under "Reference ID" \u2014 looks like "xxxxxxxxxxxxxxxxxxxx")`);
+  console.log(`  3. Settings \u2192 API: copy the service_role key (NOT the anon key \u2014 service_role`);
+  console.log(`     is below it and warns "keep secret")`);
+  console.log(`  4. Storage \u2192 New bucket: name it "bertrand", PRIVATE (uncheck "Public bucket")
+`);
+  const projectId = await prompt("Supabase Project ID");
+  if (!projectId)
+    return abort("no project ID provided");
+  if (!/^[a-z0-9]{15,30}$/i.test(projectId)) {
+    return abort(`"${projectId}" doesn't look like a Supabase project ID. ` + `Expected the 20-ish char string from Settings \u2192 General, not the project name.`);
+  }
+  const supabaseUrl = `https://${projectId}.supabase.co`;
+  console.log(`  \u2192 Project URL: ${supabaseUrl}`);
+  const supabaseServiceKey = await prompt("SUPABASE_SERVICE_KEY (eyJ\u2026)");
+  if (!supabaseServiceKey)
+    return abort("no service key provided");
+  if (!supabaseServiceKey.startsWith("eyJ")) {
+    return abort("service key must be a JWT starting with eyJ \u2014 did you paste the URL by mistake?");
+  }
+  const bucket = await prompt("Storage bucket name", { default: "bertrand" });
+  const defaultObject = `projects/${active.slug}/bertrand.db.enc`;
+  const objectKey = await prompt("Object key", { default: defaultObject });
+  const defaultName = `bertrand-${hostname2()}`;
+  const clientName = await prompt("Client name", { default: defaultName });
+  console.log(`
+Encryption key`);
+  console.log(`  First machine?    Press ENTER to generate a fresh AES-256-GCM key.`);
+  console.log(`  Additional machine? Paste the key from your other machine.
+`);
+  const pasted = await prompt("BERTRAND_ENCRYPTION_KEY");
+  let encryptionKey;
+  if (pasted) {
+    const decoded = Buffer.from(pasted, "base64");
+    if (decoded.length !== 32) {
+      return abort(`pasted key is ${decoded.length} bytes when decoded; expected 32. ` + `Copy the full key from your other machine without trimming.`);
+    }
+    encryptionKey = pasted;
+    console.log(`  \u2713 Using pasted key \u2014 this machine can decrypt blobs from the other one.
+`);
+  } else {
+    encryptionKey = generateKeyBase64();
+    console.log(`
+Generated a new key. Save this somewhere safe \u2014 you'll need it on every`);
+    console.log(`other machine that should be able to pull this project:
+`);
+    console.log(`  ${encryptionKey}
+`);
+    console.log(`Hit ENTER to confirm you've saved it.`);
+    await prompt("");
+  }
+  saveSyncConfig({ supabaseUrl, supabaseServiceKey, bucket, objectKey, encryptionKey, clientName });
+  patchConfig({ sync: { enabled: true } });
+  console.log(`Wrote ${active.syncEnv} (mode 0600). Sync auto-triggers enabled.`);
+  console.log(`
+Next:`);
+  console.log(`  bertrand sync push      Send this project's DB to Supabase`);
+  console.log(`  bertrand sync invite    Generate a bundle to import on another machine`);
+  console.log(`  bertrand sync status    See sizes and timestamps`);
+}
+async function runPush() {
+  if (!hasSyncConfig())
+    return abort("no sync config for the active project \u2014 run `bertrand sync onboard`");
+  process.stdout.write("Snapshot \u2192 encrypt \u2192 upload\u2026 ");
+  const result = await push();
+  if (result.ok) {
+    console.log(`done (${formatBytes(result.bytes)} in ${result.durationMs}ms).`);
+  } else {
+    console.log("failed.");
+    console.error(result.error);
+    process.exit(1);
+  }
+}
+async function runPull(args) {
+  if (!hasSyncConfig())
+    return abort("no sync config for the active project \u2014 run `bertrand sync onboard`");
+  const force = args.includes("--force");
+  process.stdout.write("Download \u2192 decrypt \u2192 replace\u2026 ");
+  const result = await pull({ force });
+  if (result.ok) {
+    if (result.pulled) {
+      console.log(`done (${formatBytes(result.bytes)} in ${result.durationMs}ms).`);
+    } else {
+      console.log("no remote object yet \u2014 nothing to pull.");
+    }
+  } else {
+    console.log("failed.");
+    console.error(result.error);
+    process.exit(1);
+  }
+}
+async function runStatus() {
+  const active = resolveActiveProject();
+  if (!hasSyncConfig()) {
+    console.log(`Sync is not configured for project "${active.slug}". Run \`bertrand sync onboard\` to set up.`);
+    return;
+  }
+  console.log(`Sync status for project "${active.slug}" (${active.syncEnv}):`);
+  console.log(`  Auto-triggers:       ${isSyncEnabled() ? "enabled" : "disabled"}`);
+  const s = await status();
+  if (s.local) {
+    console.log(`  Local:               ${formatBytes(s.local.size)}, modified ${formatAgo(s.local.modifiedAt)}`);
+  } else {
+    console.log(`  Local:               (no DB file yet)`);
+  }
+  if (s.remote) {
+    console.log(`  Remote:              ${formatBytes(s.remote.size)}, modified ${formatAgo(s.remote.modifiedAt)}`);
+  } else {
+    console.log(`  Remote:              (no object \u2014 push to create)`);
+  }
+}
+function runEnable() {
+  if (!hasSyncConfig()) {
+    return abort("no sync config for the active project \u2014 run `bertrand sync onboard` first");
+  }
+  patchConfig({ sync: { enabled: true } });
+  console.log("Sync auto-triggers enabled. Pull-on-launch and push-on-session-end will fire.");
+}
+function runInvite() {
+  const cfg = loadSyncConfig();
+  if (!cfg) {
+    return abort("no sync config for the active project \u2014 run `bertrand sync onboard` first");
+  }
+  const active = resolveActiveProject();
+  const invite = encodeInvite(cfg, { slug: active.slug, name: active.name });
+  console.log("Sensitive: this bundle contains a Supabase service_role token AND the project's encryption key.");
+  console.log(`Transmit only over a secure channel (Signal, iMessage, AirDrop). Treat like an SSH private key.
+`);
+  console.log(`Project: ${active.slug} (${active.name})
+`);
+  console.log(invite);
+  console.log(`
+On the other machine:`);
+  console.log(`  bertrand sync ${invite.slice(0, 32)}\u2026`);
+  console.log(`  (creates the project locally, saves config, runs first pull)`);
+}
+async function runBootstrap(invite) {
+  console.log("Importing project from invite\u2026");
+  const result = await bootstrapFromInvite(invite);
+  if (!result.ok) {
+    if (result.reason === "pull-failed") {
+      console.error(`Pull failed: ${result.error}`);
+      console.error(`(Config is saved, so you can fix and re-run \`bertrand sync pull\`.)`);
+      process.exit(1);
+    }
+    return abort(result.error);
+  }
+  const active = resolveActiveProject();
+  console.log(`Created project "${result.project.slug}" (${result.project.name}) and wrote ${active.syncEnv}.`);
+  if (result.pulled) {
+    console.log(`\u2713 Done (${formatBytes(result.bytes)} in ${result.durationMs}ms). Run \`bertrand\` to start.`);
+  } else {
+    console.log(`\u2713 Config saved, but no remote object yet \u2014 nothing to pull.`);
+    console.log(`  Run \`bertrand sync push\` on the source machine first.`);
+  }
+}
+function runDisable() {
+  patchConfig({ sync: { enabled: false } });
+  console.log("Sync auto-triggers disabled. Credentials still in place \u2014 re-enable any time with `bertrand sync enable`.");
+  console.log("Manual `bertrand sync push` / `pull` still work while disabled.");
+}
+function formatBytes(n) {
+  if (n < 1024)
+    return `${n}B`;
+  if (n < 1024 * 1024)
+    return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(2)}MB`;
+}
+var init_sync = __esm(() => {
+  init_router();
+  init_config();
+  init_engine();
+  init_crypto();
+  init_bootstrap();
+  init_registry();
+  init_resolve();
+  init_format();
+  init_config2();
+  register("sync", async (args) => {
+    const sub = args[0];
+    if (sub && isInvite(sub)) {
+      await runBootstrap(sub);
+      return;
+    }
+    const { slug: projectOverride, rest } = extractProjectFlag(args.slice(1));
+    applyProjectOverride(projectOverride);
+    switch (sub) {
+      case "push":
+        await runPush();
+        return;
+      case "pull":
+        await runPull(rest);
+        return;
+      case "status":
+        await runStatus();
+        return;
+      case "onboard":
+        await runOnboard();
+        return;
+      case "invite":
+        runInvite();
+        return;
+      case "enable":
+        runEnable();
+        return;
+      case "disable":
+        runDisable();
+        return;
+      case undefined:
+      case "--help":
+      case "-h":
+        printUsage2();
+        return;
+      default:
+        console.error(`Unknown subcommand: ${sub}`);
+        printUsage2();
+        process.exit(1);
+    }
   });
 });
 
-// src/db/queries/groups.ts
+// src/db/queries/categories.ts
 import { eq as eq6, like, or, isNull } from "drizzle-orm";
-function createGroup(opts) {
+function createCategory(opts) {
   const db = getDb();
   const id = createId();
   let path = opts.slug;
   let depth = 0;
   if (opts.parentId) {
-    const parent = db.select().from(groups).where(eq6(groups.id, opts.parentId)).get();
+    const parent = db.select().from(categories).where(eq6(categories.id, opts.parentId)).get();
     if (!parent)
-      throw new Error(`Parent group ${opts.parentId} not found`);
+      throw new Error(`Parent category ${opts.parentId} not found`);
     path = `${parent.path}/${opts.slug}`;
     depth = parent.depth + 1;
   }
-  return db.insert(groups).values({ id, slug: opts.slug, name: opts.name, parentId: opts.parentId, path, depth }).returning().get();
+  return db.insert(categories).values({ id, slug: opts.slug, name: opts.name, parentId: opts.parentId, path, depth }).returning().get();
 }
-function getGroup(id) {
-  return getDb().select().from(groups).where(eq6(groups.id, id)).get();
+function getCategory(id) {
+  return getDb().select().from(categories).where(eq6(categories.id, id)).get();
 }
-function getGroupByPath(path) {
-  return getDb().select().from(groups).where(eq6(groups.path, path)).get();
+function getCategoryByPath(path) {
+  return getDb().select().from(categories).where(eq6(categories.path, path)).get();
 }
-function getOrCreateGroupPath(path) {
-  const existing = getGroupByPath(path);
+function getOrCreateCategoryPath(path) {
+  const existing = getCategoryByPath(path);
   if (existing)
     return existing.id;
   const segments = path.split("/");
   let parentId;
   for (let i = 0;i < segments.length; i++) {
     const partialPath = segments.slice(0, i + 1).join("/");
-    const group = getGroupByPath(partialPath);
-    if (group) {
-      parentId = group.id;
+    const category = getCategoryByPath(partialPath);
+    if (category) {
+      parentId = category.id;
     } else {
       const slug = segments[i];
-      const created = createGroup({ slug, name: slug, parentId });
+      const created = createCategory({ slug, name: slug, parentId });
       parentId = created.id;
     }
   }
   return parentId;
 }
-var init_groups = __esm(() => {
+var init_categories = __esm(() => {
   init_client();
   init_schema();
   init_id();
@@ -1484,74 +2841,20 @@ var init_template2 = __esm(() => {
   init_template();
 });
 
-// src/lib/format.ts
-function formatDuration(ms) {
-  if (ms < MINUTE)
-    return `${Math.round(ms / SECOND)}s`;
-  const days = Math.floor(ms / DAY);
-  const hours = Math.floor(ms % DAY / HOUR);
-  const minutes = Math.floor(ms % HOUR / MINUTE);
-  if (days > 0)
-    return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
-  if (hours > 0)
-    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
-  return `${minutes}m`;
-}
-function formatAgo(isoOrDate) {
-  const date = typeof isoOrDate === "string" ? new Date(isoOrDate) : isoOrDate;
-  const ms = Date.now() - date.getTime();
-  if (ms < MINUTE)
-    return "just now";
-  if (ms < HOUR)
-    return `${Math.floor(ms / MINUTE)}m ago`;
-  if (ms < DAY)
-    return `${Math.floor(ms / HOUR)}h ago`;
-  if (ms < 2 * DAY)
-    return "yesterday";
-  if (ms < 7 * DAY)
-    return `${Math.floor(ms / DAY)}d ago`;
-  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
-}
-function truncate(text2, maxLen) {
-  if (text2.length <= maxLen)
-    return text2;
-  return text2.slice(0, maxLen - 1) + "\u2026";
-}
-function formatTime(iso, includeDate = false) {
-  const date = new Date(iso);
-  const time = date.toLocaleTimeString("en-US", {
-    hour: "numeric",
-    minute: "2-digit"
-  });
-  if (!includeDate)
-    return time;
-  const day = date.toLocaleDateString("en-US", {
-    month: "short",
-    day: "numeric"
-  });
-  return `${day} ${time}`;
-}
-var SECOND = 1000, MINUTE, HOUR, DAY;
-var init_format = __esm(() => {
-  MINUTE = 60 * SECOND;
-  HOUR = 60 * MINUTE;
-  DAY = 24 * HOUR;
-});
-
 // src/contract/context.ts
-function buildSiblingContext(groupId, groupPath, currentSessionId) {
-  const siblings = getSessionsByGroup(groupId).filter((s) => s.id !== currentSessionId);
+function buildSiblingContext(categoryId, categoryPath, currentSessionId) {
+  const siblings = getSessionsByCategory(categoryId).filter((s) => s.id !== currentSessionId);
   if (siblings.length === 0)
     return "";
   const lines = siblings.map((s) => {
     const ago = s.updatedAt ? formatAgo(s.updatedAt) : "unknown";
     const summary = s.summary ? ` \u2014 "${s.summary}"` : "";
-    return `- ${groupPath}/${s.slug}: ${s.status}${summary} (${ago})`;
+    return `- ${categoryPath}/${s.slug}: ${s.status}${summary} (${ago})`;
   });
   const guidance = [
     "",
     "To inspect any sibling session's full record, run:",
-    "  bertrand log <group>/<slug> --json",
+    "  bertrand log <category>/<slug> --json",
     "Returns session metadata, stats, conversations, and the full event timeline.",
     "Reach for this when the user references work done in another session, or you need to verify what was decided or tried elsewhere."
   ].join(`
@@ -1567,7 +2870,7 @@ var init_context = __esm(() => {
 });
 
 // src/engine/process.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function launchClaude(opts) {
   const args = [];
   if (opts.resume) {
@@ -1576,16 +2879,19 @@ function launchClaude(opts) {
     args.push("--session-id", opts.claudeId);
   }
   args.push("--append-system-prompt", opts.contract);
+  const active = resolveActiveProject();
   const env = {
     ...process.env,
     BERTRAND_PID: String(process.pid),
     BERTRAND_CLAUDE_ID: opts.claudeId,
     BERTRAND_SESSION: opts.sessionId,
     BERTRAND_SESSION_NAME: opts.sessionName,
-    BERTRAND_SESSION_SLUG: opts.sessionSlug
+    BERTRAND_SESSION_SLUG: opts.sessionSlug,
+    BERTRAND_PROJECT: active.slug,
+    BERTRAND_PROJECT_DB: active.db
   };
   return new Promise((resolve, reject) => {
-    const child = spawn("claude", args, {
+    const child = spawn2("claude", args, {
       env,
       stdio: "inherit",
       shell: false
@@ -1612,8 +2918,13 @@ function launchClaude(opts) {
     });
   });
 }
+function isClaudeRunning() {
+  return activeChild !== null;
+}
 var activeChild = null;
-var init_process = () => {};
+var init_process = __esm(() => {
+  init_resolve();
+});
 
 // src/engine/spawn-context.ts
 import { execFile as execFile2 } from "child_process";
@@ -1683,12 +2994,12 @@ var init_spawn_context = __esm(() => {
 });
 
 // src/lib/server-lifecycle.ts
-import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync3, writeFileSync, unlinkSync } from "fs";
-import { join as join4 } from "path";
+import { spawn as spawn3 } from "child_process";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { join as join8 } from "path";
 function readPidFile() {
   try {
-    const pid = Number(readFileSync3(deps.pidFile, "utf-8").trim());
+    const pid = Number(readFileSync7(deps.pidFile, "utf-8").trim());
     return Number.isFinite(pid) && pid > 0 ? pid : null;
   } catch {
     return null;
@@ -1714,7 +3025,7 @@ async function isPortListening(port) {
 }
 function removePidFile() {
   try {
-    unlinkSync(deps.pidFile);
+    unlinkSync2(deps.pidFile);
   } catch {}
 }
 async function ensureServerStarted() {
@@ -1728,14 +3039,14 @@ async function ensureServerStarted() {
   const bin = deps.resolveBin();
   if (!bin)
     return;
-  const child = spawn2(bin, ["serve"], {
+  const child = spawn3(bin, ["serve"], {
     detached: true,
     stdio: "ignore",
     env: { ...process.env, BERTRAND_PORT: String(deps.port) }
   });
   child.unref();
   if (child.pid)
-    writeFileSync(deps.pidFile, String(child.pid));
+    writeFileSync4(deps.pidFile, String(child.pid));
 }
 function stopServerIfIdle() {
   if (deps.getActiveCount() > 0)
@@ -1753,11 +3064,11 @@ var init_server_lifecycle = __esm(() => {
   init_paths();
   init_sessions();
   defaultDeps = {
-    pidFile: join4(paths.root, "server.pid"),
+    pidFile: join8(paths.root, "server.pid"),
     port: Number(process.env.BERTRAND_PORT ?? 5200),
     resolveBin() {
       try {
-        const config = JSON.parse(readFileSync3(join4(paths.root, "config.json"), "utf-8"));
+        const config = JSON.parse(readFileSync7(join8(paths.root, "config.json"), "utf-8"));
         return typeof config?.bin === "string" ? config.bin : null;
       } catch {
         return null;
@@ -1770,17 +3081,52 @@ var init_server_lifecycle = __esm(() => {
 
 // src/engine/session.ts
 import { randomUUID } from "crypto";
+function forceFinalizeLive() {
+  if (!liveSession)
+    return;
+  const session = getSession(liveSession.sessionId);
+  if (!session) {
+    liveSession = null;
+    return;
+  }
+  if (session.status !== "active" && session.status !== "waiting") {
+    liveSession = null;
+    return;
+  }
+  try {
+    updateSession(liveSession.sessionId, {
+      status: "paused",
+      pid: null,
+      endedAt: new Date().toISOString()
+    });
+  } catch {}
+  liveSession = null;
+}
+function installExitHandlers() {
+  if (exitHandlersInstalled)
+    return;
+  exitHandlersInstalled = true;
+  process.on("exit", forceFinalizeLive);
+  const onSignal = (signal) => {
+    if (isClaudeRunning())
+      return;
+    process.exit(signal === "SIGINT" ? 130 : signal === "SIGHUP" ? 129 : 143);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  process.on("SIGHUP", onSignal);
+}
 async function launch(opts) {
-  const existingGroup = getGroupByPath(opts.groupPath);
-  if (existingGroup) {
-    const existing = getSessionByGroupSlug(existingGroup.id, opts.slug);
+  const existingCategory = getCategoryByPath(opts.categoryPath);
+  if (existingCategory) {
+    const existing = getSessionByCategorySlug(existingCategory.id, opts.slug);
     if (existing) {
-      throw new Error(`Session "${opts.slug}" already exists in group "${opts.groupPath}"`);
+      throw new Error(`Session "${opts.slug}" already exists in category "${opts.categoryPath}"`);
     }
   }
-  const groupId = getOrCreateGroupPath(opts.groupPath);
+  const categoryId = getOrCreateCategoryPath(opts.categoryPath);
   const session = createSession({
-    groupId,
+    categoryId,
     slug: opts.slug,
     name: opts.name ?? opts.slug
   });
@@ -1794,15 +3140,17 @@ async function launch(opts) {
     sessionId: session.id
   });
   updateSession(session.id, { status: "active", pid: process.pid });
+  liveSession = { sessionId: session.id, claudeId };
+  installExitHandlers();
   await ensureServerStarted();
   const spawnContext = await captureSpawnContext();
-  const sessionName = `${opts.groupPath}/${opts.slug}`;
+  const sessionName = `${opts.categoryPath}/${opts.slug}`;
   insertEvent({
     sessionId: session.id,
     conversationId: claudeId,
     event: "session.started",
     meta: {
-      group_path: opts.groupPath,
+      category_path: opts.categoryPath,
       session_name: opts.name ?? opts.slug,
       session_slug: opts.slug,
       labels: opts.labelNames ?? [],
@@ -1821,7 +3169,7 @@ async function launch(opts) {
       cwd: spawnContext.cwd
     }
   });
-  const siblingContext = buildSiblingContext(groupId, opts.groupPath, session.id);
+  const siblingContext = buildSiblingContext(categoryId, opts.categoryPath, session.id);
   const contract = buildContract(sessionName, siblingContext);
   const exitCode = await launchClaude({
     sessionId: session.id,
@@ -1837,9 +3185,11 @@ async function resume(opts) {
   const session = getSession(opts.sessionId);
   if (!session)
     throw new Error(`Session not found: ${opts.sessionId}`);
-  const group = getGroup(session.groupId);
-  const sessionName = group ? `${group.path}/${session.slug}` : session.name;
+  const category = getCategory(session.categoryId);
+  const sessionName = category ? `${category.path}/${session.slug}` : session.name;
   updateSession(session.id, { status: "active", pid: process.pid });
+  liveSession = { sessionId: session.id, claudeId: opts.conversationId };
+  installExitHandlers();
   await ensureServerStarted();
   insertEvent({
     sessionId: session.id,
@@ -1847,8 +3197,8 @@ async function resume(opts) {
     event: "session.resumed",
     meta: { claude_id: opts.conversationId }
   });
-  const groupPath = group?.path ?? "";
-  const siblingContext = buildSiblingContext(session.groupId, groupPath, session.id);
+  const categoryPath = category?.path ?? "";
+  const siblingContext = buildSiblingContext(session.categoryId, categoryPath, session.id);
   const contract = buildContract(sessionName, siblingContext);
   const exitCode = await launchClaude({
     sessionId: session.id,
@@ -1880,6 +3230,8 @@ function finalizeSession(sessionId, conversationId, exitCode) {
     pid: null,
     endedAt: new Date().toISOString()
   });
+  if (liveSession?.sessionId === sessionId)
+    liveSession = null;
   insertEvent({
     sessionId,
     event: "session.end"
@@ -1887,11 +3239,12 @@ function finalizeSession(sessionId, conversationId, exitCode) {
   computeAndPersist(sessionId);
   stopServerIfIdle();
 }
+var liveSession = null, exitHandlersInstalled = false;
 var init_session = __esm(() => {
   init_sessions();
   init_conversations();
   init_events();
-  init_groups();
+  init_categories();
   init_labels();
   init_template2();
   init_context();
@@ -1902,13 +3255,13 @@ var init_session = __esm(() => {
 });
 
 // src/tui/app.tsx
-import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync4, unlinkSync as unlinkSync2 } from "fs";
-import { join as join5 } from "path";
+import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync8, readFileSync as readFileSync8, unlinkSync as unlinkSync3 } from "fs";
+import { join as join9 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 async function runScreen(screen, ...args) {
   const tmpFile = `/tmp/bertrand-tui-${process.pid}-${Date.now()}.json`;
-  const child = spawn3("bun", ["run", SCREEN_ENTRY, screen, tmpFile, ...args], {
+  const child = spawn4("bun", ["run", SCREEN_ENTRY, screen, tmpFile, ...args], {
     stdio: "inherit"
   });
   const exitCode = await new Promise((resolve) => {
@@ -1917,13 +3270,16 @@ async function runScreen(screen, ...args) {
   if (exitCode !== 0) {
     throw new Error(`TUI screen "${screen}" exited with code ${exitCode}`);
   }
-  const result = JSON.parse(readFileSync4(tmpFile, "utf-8"));
-  unlinkSync2(tmpFile);
+  const result = JSON.parse(readFileSync8(tmpFile, "utf-8"));
+  unlinkSync3(tmpFile);
   return result;
 }
 async function startLaunchTui() {
   return runScreen("launch");
 }
+async function startProjectPickerTui() {
+  return runScreen("project-picker");
+}
 async function startExitTui(sessionId) {
   return runScreen("exit", sessionId);
 }
@@ -1972,26 +3328,58 @@ async function runSessionLoop(sessionId) {
     }
   }
 }
-async function startTui() {
+function shouldShowProjectPicker() {
+  if (process.env.BERTRAND_PROJECT)
+    return false;
+  const projects = listProjects();
+  return projects.length !== 1;
+}
+function activateProject(slug) {
+  setActiveProjectSlug(slug);
+  _resetActiveProjectCache();
+}
+async function runLaunchCycle() {
   const selection = await startLaunchTui();
   switch (selection.type) {
     case "quit":
-      break;
+      return;
     case "create": {
       const sessionId = await launch(selection);
       await runSessionLoop(sessionId);
-      break;
+      return;
     }
     case "pick": {
       const conversationId = await resolveConversationForResume(selection.sessionId);
       if (!conversationId)
-        break;
+        return;
       const sessionId = await resume({
         sessionId: selection.sessionId,
         conversationId
       });
       await runSessionLoop(sessionId);
-      break;
+      return;
+    }
+  }
+}
+async function startTui() {
+  if (!shouldShowProjectPicker()) {
+    await runLaunchCycle();
+    return;
+  }
+  const projectSelection = await startProjectPickerTui();
+  switch (projectSelection.type) {
+    case "quit":
+      return;
+    case "select": {
+      activateProject(projectSelection.slug);
+      await runLaunchCycle();
+      return;
+    }
+    case "create": {
+      createProject({ slug: projectSelection.slug });
+      activateProject(projectSelection.slug);
+      await runLaunchCycle();
+      return;
     }
   }
 }
@@ -2001,9 +3389,12 @@ var init_app = __esm(() => {
   init_conversations();
   init_session_archive();
   init_session();
+  init_registry();
+  init_create();
+  init_resolve();
   SCREEN_ENTRY = (() => {
-    const built = join5(import.meta.dir, "run-screen.js");
-    return existsSync4(built) ? built : join5(import.meta.dir, "run-screen.tsx");
+    const built = join9(import.meta.dir, "run-screen.js");
+    return existsSync8(built) ? built : join9(import.meta.dir, "run-screen.tsx");
   })();
 });
 
@@ -2015,7 +3406,7 @@ function parseSessionName(input) {
   }
   const segments = trimmed.split("/").filter(Boolean);
   if (segments.length < 2) {
-    throw new Error(`Session name must include at least one group: "group/session" (got "${trimmed}")`);
+    throw new Error(`Session name must include at least one category: "category/session" (got "${trimmed}")`);
   }
   for (const segment of segments) {
     if (!/^[a-z0-9][a-z0-9._-]*$/i.test(segment)) {
@@ -2023,8 +3414,8 @@ function parseSessionName(input) {
     }
   }
   const slug = segments[segments.length - 1];
-  const groupPath = segments.slice(0, -1).join("/");
-  return { groupPath, slug };
+  const categoryPath = segments.slice(0, -1).join("/");
+  return { categoryPath, slug };
 }
 
 // src/engine/recovery.ts
@@ -2072,8 +3463,8 @@ var init_launch = __esm(() => {
     recoverStaleSessions();
     const sessionName = args[0];
     if (sessionName) {
-      const { groupPath, slug } = parseSessionName(sessionName);
-      const sessionId = await launch({ groupPath, slug });
+      const { categoryPath, slug } = parseSessionName(sessionName);
+      const sessionId = await launch({ categoryPath, slug });
       await runSessionLoop(sessionId);
       return;
     }
@@ -2081,28 +3472,6 @@ var init_launch = __esm(() => {
   });
 });
 
-// src/db/migrate.ts
-import { Database as Database2 } from "bun:sqlite";
-import { drizzle as drizzle2 } from "drizzle-orm/bun-sqlite";
-import { migrate } from "drizzle-orm/bun-sqlite/migrator";
-import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
-function runMigrations() {
-  mkdirSync2(dirname2(paths.db), { recursive: true });
-  const sqlite = new Database2(paths.db);
-  sqlite.exec("PRAGMA journal_mode = WAL");
-  sqlite.exec("PRAGMA foreign_keys = ON");
-  const db = drizzle2(sqlite);
-  migrate(db, { migrationsFolder: MIGRATIONS_FOLDER });
-  sqlite.close();
-}
-var MIGRATIONS_FOLDER;
-var init_migrate = __esm(() => {
-  init_paths();
-  MIGRATIONS_FOLDER = import.meta.dir + "/migrations";
-  if (false) {}
-});
-
 // src/hooks/scripts.ts
 function waitingScript(bin) {
   const BIN = bin;
@@ -2376,14 +3745,14 @@ var init_scripts = __esm(() => {
 });
 
 // src/hooks/install.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, chmodSync } from "fs";
-import { join as join6 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync5, chmodSync as chmodSync2 } from "fs";
+import { join as join10 } from "path";
 function installHookScripts(bin) {
-  mkdirSync3(paths.hooks, { recursive: true });
+  mkdirSync7(paths.hooks, { recursive: true });
   for (const [filename, scriptFn] of Object.entries(HOOK_SCRIPTS)) {
-    const filePath = join6(paths.hooks, filename);
-    writeFileSync2(filePath, scriptFn(bin));
-    chmodSync(filePath, 493);
+    const filePath = join10(paths.hooks, filename);
+    writeFileSync5(filePath, scriptFn(bin));
+    chmodSync2(filePath, 493);
   }
   console.log(`Installed ${Object.keys(HOOK_SCRIPTS).length} hook scripts to ${paths.hooks}`);
 }
@@ -2393,8 +3762,8 @@ var init_install = __esm(() => {
 });
 
 // src/hooks/settings.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync8 } from "fs";
+import { join as join11, dirname as dirname4 } from "path";
 import { homedir as homedir2 } from "os";
 function isBertrandGroup(group) {
   return group.hooks?.some((h) => h.command?.includes(".bertrand/hooks/")) ?? false;
@@ -2402,7 +3771,7 @@ function isBertrandGroup(group) {
 function installHookSettings() {
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync5(SETTINGS_PATH, "utf-8"));
+    settings = JSON.parse(readFileSync9(SETTINGS_PATH, "utf-8"));
   } catch {}
   const existingHooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
   const merged = { ...existingHooks };
@@ -2411,15 +3780,15 @@ function installHookSettings() {
     merged[eventType] = [...existing, ...bertrandGroups];
   }
   settings.hooks = merged;
-  mkdirSync4(dirname3(SETTINGS_PATH), { recursive: true });
-  writeFileSync3(SETTINGS_PATH, JSON.stringify(settings, null, 2) + `
+  mkdirSync8(dirname4(SETTINGS_PATH), { recursive: true });
+  writeFileSync6(SETTINGS_PATH, JSON.stringify(settings, null, 2) + `
 `);
   console.log(`Updated ${SETTINGS_PATH} with bertrand hooks`);
 }
 var SETTINGS_PATH, BERTRAND_HOOKS;
 var init_settings = __esm(() => {
   init_paths();
-  SETTINGS_PATH = join7(homedir2(), ".claude", "settings.json");
+  SETTINGS_PATH = join11(homedir2(), ".claude", "settings.json");
   BERTRAND_HOOKS = {
     PreToolUse: [
       {
@@ -2463,8 +3832,8 @@ var init_settings = __esm(() => {
 });
 
 // src/lib/completions.ts
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
-import { join as join8 } from "path";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
+import { join as join12 } from "path";
 function bashCompletion() {
   return `# bertrand bash completion
 _bertrand() {
@@ -2494,11 +3863,11 @@ function fishCompletion() {
 `;
 }
 function generateCompletions() {
-  const dir = join8(paths.root, "completions");
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync4(join8(dir, "bertrand.bash"), bashCompletion());
-  writeFileSync4(join8(dir, "_bertrand"), zshCompletion());
-  writeFileSync4(join8(dir, "bertrand.fish"), fishCompletion());
+  const dir = join12(paths.root, "completions");
+  mkdirSync9(dir, { recursive: true });
+  writeFileSync7(join12(dir, "bertrand.bash"), bashCompletion());
+  writeFileSync7(join12(dir, "_bertrand"), zshCompletion());
+  writeFileSync7(join12(dir, "bertrand.fish"), fishCompletion());
   console.log(`Shell completions written to ${dir}`);
   console.log("  Add to your shell config:");
   console.log(`    bash: source ${dir}/bertrand.bash`);
@@ -2514,8 +3883,10 @@ var init_completions = __esm(() => {
     "log",
     "stats",
     "archive",
+    "project",
     "update",
     "serve",
+    "sync",
     "import",
     "completion",
     "badge",
@@ -2525,9 +3896,9 @@ var init_completions = __esm(() => {
 
 // src/cli/commands/init.ts
 var exports_init = {};
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5, chmodSync as chmodSync2 } from "fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync8, chmodSync as chmodSync3 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join9 } from "path";
+import { join as join13 } from "path";
 function detectTerminal() {
   try {
     execSync2("which wsh", { stdio: "ignore" });
@@ -2536,51 +3907,42 @@ function detectTerminal() {
     return "other";
   }
 }
-function writeConfig(config) {
-  writeFileSync5(CONFIG_PATH, JSON.stringify(config, null, 2) + `
-`);
-}
-function readConfig() {
-  try {
-    return JSON.parse(readFileSync6(CONFIG_PATH, "utf-8"));
-  } catch {
-    return null;
-  }
-}
 function resolveBin() {
   const onPath = Bun.which("bertrand");
   if (onPath)
     return onPath;
   const entry = process.argv[1];
   if (entry && SOURCE_ENTRY.test(entry)) {
-    const launcherDir = join9(paths.root, "bin");
-    const launcher = join9(launcherDir, "bertrand-dev");
-    mkdirSync6(launcherDir, { recursive: true });
-    writeFileSync5(launcher, `#!/usr/bin/env bash
+    const launcherDir = join13(paths.root, "bin");
+    const launcher = join13(launcherDir, "bertrand-dev");
+    mkdirSync10(launcherDir, { recursive: true });
+    writeFileSync8(launcher, `#!/usr/bin/env bash
 exec ${process.execPath} ${JSON.stringify(entry)} "$@"
 `);
-    chmodSync2(launcher, 493);
+    chmodSync3(launcher, 493);
     return launcher;
   }
   return null;
 }
-var CONFIG_PATH, SOURCE_ENTRY;
+var SOURCE_ENTRY;
 var init_init = __esm(() => {
   init_router();
   init_migrate();
   init_install();
   init_settings();
   init_paths();
+  init_resolve();
   init_completions();
-  CONFIG_PATH = join9(paths.root, "config.json");
+  init_config2();
   SOURCE_ENTRY = /\/src\/index\.tsx?$/;
   register("init", async () => {
     console.log(`bertrand init
 `);
-    mkdirSync6(paths.root, { recursive: true });
-    mkdirSync6(paths.hooks, { recursive: true });
-    runMigrations();
-    console.log(`  Database: ${paths.db}`);
+    mkdirSync10(paths.root, { recursive: true });
+    mkdirSync10(paths.hooks, { recursive: true });
+    const active = resolveActiveProject();
+    runMigrations(active.db);
+    console.log(`  Database: ${active.db}`);
     const bin = resolveBin();
     if (!bin) {
       console.error(`
@@ -2614,7 +3976,7 @@ function buildRows(sessions2) {
   return sessions2.sort((a, b) => new Date(b.session.updatedAt).getTime() - new Date(a.session.updatedAt).getTime()).map((row) => {
     const stats = getSessionStats(row.session.id);
     return {
-      name: `${row.groupPath}/${row.session.slug}`,
+      name: `${row.categoryPath}/${row.session.slug}`,
       status: row.session.status,
       updatedAt: row.session.updatedAt,
       conversations: stats?.conversationCount ?? 0,
@@ -2654,7 +4016,7 @@ var STATUS_DOTS;
 var init_list = __esm(() => {
   init_router();
   init_sessions();
-  init_groups();
+  init_categories();
   init_stats();
   init_format();
   STATUS_DOTS = {
@@ -2667,17 +4029,17 @@ var init_list = __esm(() => {
   register("list", async (args) => {
     const isJson = args.includes("--json");
     const showAll = args.includes("--all") || args.includes("-a");
-    const groupFlag = args.indexOf("--group");
-    const groupPath = groupFlag !== -1 ? args[groupFlag + 1] : undefined;
+    const categoryFlag = args.indexOf("--category");
+    const categoryPath = categoryFlag !== -1 ? args[categoryFlag + 1] : undefined;
     let sessionRows;
-    if (groupPath) {
-      const group = getGroupByPath(groupPath);
-      if (!group) {
-        console.error(`Group not found: ${groupPath}`);
+    if (categoryPath) {
+      const category = getCategoryByPath(categoryPath);
+      if (!category) {
+        console.error(`Category not found: ${categoryPath}`);
         process.exit(1);
       }
-      const groupSessions = getSessionsByGroup(group.id);
-      sessionRows = groupSessions.map((s) => ({ session: s, groupPath: group.path }));
+      const categorySessions = getSessionsByCategory(category.id);
+      sessionRows = categorySessions.map((s) => ({ session: s, categoryPath: category.path }));
       if (!showAll) {
         sessionRows = sessionRows.filter((r) => r.session.status !== "archived");
       }
@@ -2924,10 +4286,10 @@ function showAllSessions() {
     console.log("No sessions.");
     return;
   }
-  const maxName = Math.max(...rows.map((r) => `${r.groupPath}/${r.session.slug}`.length), 4);
+  const maxName = Math.max(...rows.map((r) => `${r.categoryPath}/${r.session.slug}`.length), 4);
   console.log(`${DIM}${"  "} ${"NAME".padEnd(maxName)}  ${"STATUS".padEnd(10)}  ${"EVENTS".padEnd(6)}  LAST ACTIVE${RESET}`);
   for (const row of rows) {
-    const name = `${row.groupPath}/${row.session.slug}`;
+    const name = `${row.categoryPath}/${row.session.slug}`;
     const dot = STATUS_DOTS2[row.session.status] ?? "?";
     const stats = getSessionStats(row.session.id);
     const eventCount = String(stats?.eventCount ?? 0).padEnd(6);
@@ -3084,7 +4446,7 @@ var init_log = __esm(() => {
   init_router();
   init_sessions();
   init_events();
-  init_groups();
+  init_categories();
   init_stats();
   init_conversations();
   init_catalog();
@@ -3105,27 +4467,27 @@ var init_log = __esm(() => {
       showAllSessions();
       return;
     }
-    const { groupPath, slug } = parseSessionName(target);
-    const group = getGroupByPath(groupPath);
-    if (!group) {
-      console.error(`Group not found: ${groupPath}`);
+    const { categoryPath, slug } = parseSessionName(target);
+    const category = getCategoryByPath(categoryPath);
+    if (!category) {
+      console.error(`Category not found: ${categoryPath}`);
       process.exit(1);
     }
-    const session = getSessionByGroupSlug(group.id, slug);
+    const session = getSessionByCategorySlug(category.id, slug);
     if (!session) {
       console.error(`Session not found: ${target}`);
       process.exit(1);
     }
-    showSessionLog(session, `${groupPath}/${slug}`, isJson);
+    showSessionLog(session, `${categoryPath}/${slug}`, isJson);
   });
 });
 
 // src/cli/commands/stats.ts
 var exports_stats = {};
-function getMetrics(sessionId, name, status) {
+function getMetrics(sessionId, name, status2) {
   const stats = getSessionStats(sessionId);
   if (stats) {
-    return { name, status, ...stats };
+    return { name, status: status2, ...stats };
   }
   const timing = computeTimingsLive(sessionId);
   const allEvents = getEventsBySession(sessionId);
@@ -3142,7 +4504,7 @@ function getMetrics(sessionId, name, status) {
   }
   return {
     name,
-    status,
+    status: status2,
     eventCount: allEvents.length,
     conversationCount: conversations2.size,
     interactionCount,
@@ -3189,7 +4551,7 @@ function renderGlobal(metrics, isJson) {
   console.log(`  PRs:           ${totals.prs}`);
   console.log(`  Interactions:  ${totals.interactions}`);
 }
-function renderGroup(metrics, groupPath, isJson) {
+function renderCategory(metrics, categoryPath, isJson) {
   if (isJson) {
     console.log(JSON.stringify(metrics, null, 2));
     return;
@@ -3199,7 +4561,7 @@ function renderGroup(metrics, groupPath, isJson) {
   const reset = "\x1B[0m";
   const sorted = [...metrics].sort((a, b) => b.durationS - a.durationS);
   const maxName = Math.max(...sorted.map((m) => m.name.length), 4);
-  console.log(`${bold}${groupPath}${reset}
+  console.log(`${bold}${categoryPath}${reset}
 `);
   console.log(`${dim}${"NAME".padEnd(maxName)}  ${"DURATION".padEnd(8)}  ${"CLAUDE".padEnd(8)}  ${"WAIT".padEnd(8)}  ${"ACT%".padEnd(5)}  ${"CONVOS".padEnd(6)}  PRS${reset}`);
   for (const m of sorted) {
@@ -3240,7 +4602,7 @@ var init_stats2 = __esm(() => {
   init_router();
   init_sessions();
   init_stats();
-  init_groups();
+  init_categories();
   init_events();
   init_timing();
   init_format();
@@ -3251,34 +4613,34 @@ var init_stats2 = __esm(() => {
     const target = filteredArgs[0];
     if (!target) {
       const rows = getAllSessions();
-      const metrics = rows.map((r) => getMetrics(r.session.id, `${r.groupPath}/${r.session.slug}`, r.session.status));
+      const metrics = rows.map((r) => getMetrics(r.session.id, `${r.categoryPath}/${r.session.slug}`, r.session.status));
       renderGlobal(metrics, isJson);
       return;
     }
     if (target.endsWith("/")) {
-      const groupPath2 = target.replace(/\/+$/, "");
-      const group2 = getGroupByPath(groupPath2);
-      if (!group2) {
-        console.error(`Group not found: ${groupPath2}`);
+      const categoryPath2 = target.replace(/\/+$/, "");
+      const category2 = getCategoryByPath(categoryPath2);
+      if (!category2) {
+        console.error(`Category not found: ${categoryPath2}`);
         process.exit(1);
       }
-      const groupSessions = getSessionsByGroup(group2.id);
-      const metrics = groupSessions.map((s) => getMetrics(s.id, s.slug, s.status));
-      renderGroup(metrics, groupPath2, isJson);
+      const categorySessions = getSessionsByCategory(category2.id);
+      const metrics = categorySessions.map((s) => getMetrics(s.id, s.slug, s.status));
+      renderCategory(metrics, categoryPath2, isJson);
       return;
     }
-    const { groupPath, slug } = parseSessionName(target);
-    const group = getGroupByPath(groupPath);
-    if (!group) {
-      console.error(`Group not found: ${groupPath}`);
+    const { categoryPath, slug } = parseSessionName(target);
+    const category = getCategoryByPath(categoryPath);
+    if (!category) {
+      console.error(`Category not found: ${categoryPath}`);
       process.exit(1);
     }
-    const session = getSessionByGroupSlug(group.id, slug);
+    const session = getSessionByCategorySlug(category.id, slug);
     if (!session) {
       console.error(`Session not found: ${target}`);
       process.exit(1);
     }
-    const m = getMetrics(session.id, `${groupPath}/${slug}`, session.status);
+    const m = getMetrics(session.id, `${categoryPath}/${slug}`, session.status);
     renderSession(m, isJson);
   });
 });
@@ -3293,9 +4655,9 @@ var init_backfill_stats = __esm(() => {
     const includeArchived = args.includes("--include-archived");
     const rows = getAllSessions({ excludeArchived: !includeArchived });
     console.log(`Backfilling stats for ${rows.length} session(s)${includeArchived ? "" : " (excluding archived)"}...`);
-    for (const { session, groupPath } of rows) {
+    for (const { session, categoryPath } of rows) {
       computeAndPersist(session.id);
-      console.log(`  \u2713 ${groupPath}/${session.slug}`);
+      console.log(`  \u2713 ${categoryPath}/${session.slug}`);
     }
     console.log("Done.");
   });
@@ -3304,23 +4666,23 @@ var init_backfill_stats = __esm(() => {
 // src/cli/commands/archive.ts
 var exports_archive = {};
 function resolveSession(name) {
-  const { groupPath, slug } = parseSessionName(name);
-  const group = getGroupByPath(groupPath);
-  if (!group) {
-    console.error(`Group not found: ${groupPath}`);
+  const { categoryPath, slug } = parseSessionName(name);
+  const category = getCategoryByPath(categoryPath);
+  if (!category) {
+    console.error(`Category not found: ${categoryPath}`);
     process.exit(1);
   }
-  const session = getSessionByGroupSlug(group.id, slug);
+  const session = getSessionByCategorySlug(category.id, slug);
   if (!session) {
     console.error(`Session not found: ${name}`);
     process.exit(1);
   }
-  return { session, groupPath };
+  return { session, categoryPath };
 }
 var init_archive = __esm(() => {
   init_router();
   init_sessions();
-  init_groups();
+  init_categories();
   init_session_archive();
   register("archive", async (args) => {
     const isUndo = args.includes("--undo");
@@ -3333,8 +4695,8 @@ var init_archive = __esm(() => {
         console.log("No paused sessions to archive.");
         return;
       }
-      for (const { session: session2, groupPath: groupPath2 } of archived) {
-        console.log(`  archived ${groupPath2}/${session2.slug}`);
+      for (const { session: session2, categoryPath: categoryPath2 } of archived) {
+        console.log(`  archived ${categoryPath2}/${session2.slug}`);
       }
       console.log(`
 Archived ${archived.length} session${archived.length === 1 ? "" : "s"}.`);
@@ -3346,8 +4708,8 @@ Archived ${archived.length} session${archived.length === 1 ? "" : "s"}.`);
       console.error("       bertrand archive --all-paused");
       process.exit(1);
     }
-    const { session, groupPath } = resolveSession(sessionName);
-    const fullName = `${groupPath}/${session.slug}`;
+    const { session, categoryPath } = resolveSession(sessionName);
+    const fullName = `${categoryPath}/${session.slug}`;
     if (isUndo) {
       const result2 = unarchiveSession(session.id);
       if (!result2.ok) {
@@ -3380,6 +4742,302 @@ Archived ${archived.length} session${archived.length === 1 ? "" : "s"}.`);
   });
 });
 
+// src/cli/commands/project.ts
+var exports_project = {};
+__export(exports_project, {
+  switchSubcommand: () => switchSubcommand,
+  renameSubcommand: () => renameSubcommand,
+  removeSubcommand: () => removeSubcommand,
+  listSubcommand: () => listSubcommand,
+  importSubcommand: () => importSubcommand,
+  currentSubcommand: () => currentSubcommand,
+  createSubcommand: () => createSubcommand,
+  _UsageError: () => _UsageError
+});
+import { existsSync as existsSync9, rmSync } from "fs";
+function countSessions(slug) {
+  const dbFile = projectPaths(slug).db;
+  if (!existsSync9(dbFile))
+    return { total: 0, active: 0 };
+  try {
+    const db = getDbForProject(slug);
+    const all = db.select({ status: sessions.status }).from(sessions).all();
+    return {
+      total: all.length,
+      active: all.filter((s) => s.status === "active" || s.status === "waiting").length
+    };
+  } catch {
+    return UNREADABLE_COUNTS;
+  }
+}
+function validateSlug(slug) {
+  if (!slug) {
+    throw new UsageError("Slug required.");
+  }
+  if (!SLUG_PATTERN.test(slug)) {
+    throw new UsageError(`Invalid slug "${slug}": must start with alphanumeric and contain only letters, digits, dots, underscores, or dashes.`);
+  }
+}
+function flagKey(token) {
+  if (!token.startsWith("--"))
+    return null;
+  const eq8 = token.indexOf("=");
+  return eq8 === -1 ? token.slice(2) : token.slice(2, eq8);
+}
+function flagInlineValue(token) {
+  if (!token.startsWith("--"))
+    return null;
+  const eq8 = token.indexOf("=");
+  return eq8 === -1 ? null : token.slice(eq8 + 1);
+}
+function parseFlag(args, name) {
+  for (let i = 0;i < args.length; i++) {
+    const key = flagKey(args[i]);
+    if (key !== name)
+      continue;
+    const inline = flagInlineValue(args[i]);
+    if (inline !== null)
+      return inline;
+    return args[i + 1];
+  }
+  return;
+}
+function hasFlag(args, name) {
+  return args.some((a) => flagKey(a) === name);
+}
+function positional(args) {
+  const out = [];
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      if (a.includes("="))
+        continue;
+      const next = args[i + 1];
+      if (next && !next.startsWith("--"))
+        i++;
+      continue;
+    }
+    out.push(a);
+  }
+  return out;
+}
+function listSubcommand(args) {
+  const isJson = hasFlag(args, "json");
+  const projects = listProjects();
+  const activeSlug = getActiveProjectSlug();
+  const rows = projects.map((p) => ({
+    slug: p.slug,
+    name: p.name,
+    active: p.slug === activeSlug,
+    sessions: countSessions(p.slug),
+    lastUsedAt: p.lastUsedAt
+  }));
+  if (isJson) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log("No projects registered yet.");
+    return;
+  }
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  const bold = "\x1B[1m";
+  const maxSlug = Math.max(...rows.map((r) => r.slug.length), 4);
+  const maxName = Math.max(...rows.map((r) => r.name.length), 4);
+  console.log(`${dim}  ${"SLUG".padEnd(maxSlug)}  ${"NAME".padEnd(maxName)}  ${"SESSIONS".padEnd(10)}  LAST USED${reset}`);
+  for (const r of rows) {
+    const marker = r.active ? `${bold}*${reset}` : " ";
+    const sessionStr = r.sessions.unreadable ? "?".padEnd(10) : `${r.sessions.total} (${r.sessions.active} active)`.padEnd(10);
+    const ago = formatAgo(r.lastUsedAt);
+    console.log(`${marker} ${r.slug.padEnd(maxSlug)}  ${r.name.padEnd(maxName)}  ${sessionStr}  ${ago}`);
+  }
+}
+function createSubcommand(args) {
+  const [slug] = positional(args);
+  validateSlug(slug ?? "");
+  const customName = parseFlag(args, "name");
+  const activate = hasFlag(args, "activate");
+  if (listProjects().some((p) => p.slug === slug)) {
+    throw new UsageError(`Project "${slug}" already exists.`);
+  }
+  createProject({ slug, name: customName });
+  if (activate) {
+    setActiveProjectSlug(slug);
+    _resetActiveProjectCache();
+  }
+  console.log(`Created project "${slug}"${activate ? " (now active)" : ""}.`);
+}
+function switchSubcommand(args) {
+  const [slug] = positional(args);
+  if (!slug) {
+    throw new UsageError("Usage: bertrand project switch <slug>");
+  }
+  const projects = listProjects();
+  if (!projects.some((p) => p.slug === slug)) {
+    throw new UsageError(`Unknown project slug "${slug}".`);
+  }
+  const currentSlug = getActiveProjectSlug();
+  if (currentSlug !== slug) {
+    const counts = countSessions(currentSlug);
+    if (counts.active > 0) {
+      throw new UsageError(`Cannot switch: project "${currentSlug}" has ${counts.active} active/waiting session(s). Pause them first.`);
+    }
+  }
+  setActiveProjectSlug(slug);
+  _resetActiveProjectCache();
+  console.log(`Switched active project to "${slug}".`);
+}
+function currentSubcommand(args) {
+  const isJson = hasFlag(args, "json");
+  const active = resolveActiveProject();
+  if (isJson) {
+    console.log(JSON.stringify(active, null, 2));
+    return;
+  }
+  console.log(`Active project: ${active.slug} (${active.name})`);
+  console.log(`  Root:    ${active.root}`);
+  console.log(`  DB:      ${active.db}`);
+  console.log(`  SyncEnv: ${active.syncEnv}`);
+}
+function renameSubcommand(args) {
+  const [slug, ...rest] = positional(args);
+  const newName = rest.join(" ");
+  if (!slug || !newName) {
+    throw new UsageError("Usage: bertrand project rename <slug> <new-name>");
+  }
+  renameProject(slug, newName);
+  console.log(`Renamed "${slug}" to "${newName}".`);
+}
+function removeSubcommand(args) {
+  const [slug] = positional(args);
+  if (!slug) {
+    throw new UsageError("Usage: bertrand project remove <slug> [--force] [--purge]");
+  }
+  validateSlug(slug);
+  const force = hasFlag(args, "force");
+  const purge = hasFlag(args, "purge");
+  const projects = listProjects();
+  const entry = projects.find((p) => p.slug === slug);
+  if (!entry) {
+    throw new UsageError(`Unknown project slug "${slug}".`);
+  }
+  if (slug === getActiveProjectSlug()) {
+    throw new UsageError(`Cannot remove the active project "${slug}". Switch to another project first.`);
+  }
+  if (!force) {
+    const counts = countSessions(slug);
+    if (counts.total > 0) {
+      throw new UsageError(`Project "${slug}" has ${counts.total} session(s). Pass --force to remove anyway.`);
+    }
+  }
+  removeProject(slug);
+  invalidateDbCache(slug);
+  if (purge) {
+    rmSync(projectPaths(slug).root, { recursive: true, force: true });
+  }
+  console.log(`Removed project "${slug}"${purge ? " (directory purged)" : " (directory left on disk; pass --purge to delete)"}.`);
+}
+async function importSubcommand(args) {
+  const [bundle] = positional(args);
+  if (!bundle) {
+    throw new UsageError("Usage: bertrand project import <bundle>");
+  }
+  if (!isInvite(bundle)) {
+    throw new UsageError(`Argument doesn't look like an invite bundle (expected to start with bertrand-sync://). ` + `Generate one on the source machine via \`bertrand sync invite\`.`);
+  }
+  console.log("Importing project from invite\u2026");
+  const result = await bootstrapFromInvite(bundle);
+  if (!result.ok) {
+    throw new UsageError(result.error);
+  }
+  console.log(`\u2713 Created project "${result.project.slug}" (${result.project.name}) and activated it.`);
+  if (result.pulled) {
+    console.log(`  Pulled ${result.bytes} bytes in ${result.durationMs}ms.`);
+  } else {
+    console.log(`  No remote object yet \u2014 run \`bertrand sync push\` on the source machine first.`);
+  }
+}
+function printProjectUsage() {
+  console.log(`
+bertrand project \u2014 manage projects
+
+Usage:
+  bertrand project list [--json]                  List all projects
+  bertrand project create <slug> [--name "..."] [--activate]
+                                                  Create a new project
+  bertrand project switch <slug>                  Set the active project
+  bertrand project current [--json]               Show the active project
+  bertrand project rename <slug> <new-name>       Rename a project (display name only)
+  bertrand project remove <slug> [--force] [--purge]
+                                                  Remove a project entry
+  bertrand project import <bundle>                Import a project from a \`bertrand sync invite\` bundle
+`.trim());
+}
+var SLUG_PATTERN, UsageError, UNREADABLE_COUNTS, KNOWN_SUBS, _UsageError;
+var init_project = __esm(() => {
+  init_router();
+  init_client();
+  init_schema();
+  init_registry();
+  init_paths2();
+  init_create();
+  init_resolve();
+  init_bootstrap();
+  init_format();
+  SLUG_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
+  UsageError = class UsageError extends Error {
+  };
+  UNREADABLE_COUNTS = { total: 0, active: 0, unreadable: true };
+  KNOWN_SUBS = new Set([
+    "list",
+    "create",
+    "switch",
+    "current",
+    "rename",
+    "remove",
+    "import"
+  ]);
+  register("project", async (args) => {
+    const sub = args[0];
+    try {
+      switch (sub) {
+        case "list":
+          return listSubcommand(args.slice(1));
+        case "create":
+          return createSubcommand(args.slice(1));
+        case "switch":
+          return switchSubcommand(args.slice(1));
+        case "current":
+          return currentSubcommand(args.slice(1));
+        case "rename":
+          return renameSubcommand(args.slice(1));
+        case "remove":
+          return removeSubcommand(args.slice(1));
+        case "import":
+          return await importSubcommand(args.slice(1));
+        case undefined:
+        case "--help":
+        case "-h":
+          printProjectUsage();
+          return;
+        default:
+          throw new UsageError(`Unknown subcommand: ${sub}`);
+      }
+    } catch (err) {
+      if (err instanceof UsageError) {
+        console.error(err.message);
+        if (sub && !KNOWN_SUBS.has(sub)) {
+          printProjectUsage();
+        }
+        process.exit(1);
+      }
+      throw err;
+    }
+  });
+  _UsageError = UsageError;
+});
+
 // src/index.ts
 init_router();
 var command = process.argv[2];
@@ -3390,7 +5048,8 @@ var hotPath = {
   "recap-thinking": () => Promise.resolve().then(() => (init_recap_thinking(), exports_recap_thinking)),
   badge: () => Promise.resolve().then(() => (init_badge(), exports_badge)),
   notify: () => Promise.resolve().then(() => (init_notify(), exports_notify)),
-  serve: () => Promise.resolve().then(() => (init_serve(), exports_serve))
+  serve: () => Promise.resolve().then(() => (init_serve(), exports_serve)),
+  sync: () => Promise.resolve().then(() => (init_sync(), exports_sync))
 };
 if (command && command in hotPath) {
   await hotPath[command]();
@@ -3409,7 +5068,9 @@ if (command && command in hotPath) {
     Promise.resolve().then(() => (init_recap_thinking(), exports_recap_thinking)),
     Promise.resolve().then(() => (init_serve(), exports_serve)),
     Promise.resolve().then(() => (init_badge(), exports_badge)),
-    Promise.resolve().then(() => (init_notify(), exports_notify))
+    Promise.resolve().then(() => (init_notify(), exports_notify)),
+    Promise.resolve().then(() => (init_sync(), exports_sync)),
+    Promise.resolve().then(() => (init_project(), exports_project))
   ]);
 }
 await route(process.argv);