bertrand 0.18.0 → 0.20.0

package/dist/bertrand.js

@@ -23,20 +23,325 @@ 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"),
+    db: join(homedir(), BERTRAND_DIR, "bertrand.db"),
     syncEnv: join(homedir(), BERTRAND_DIR, "sync.env")
   };
 });
 
-// src/sync/config.ts
+// src/lib/projects/registry.ts
 import {
+  existsSync,
+  mkdirSync,
   readFileSync,
+  readdirSync,
+  renameSync,
   statSync,
-  writeFileSync,
+  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
+  existsSync as existsSync3
 } from "fs";
 function parseEnv(contents) {
   const out = {};
@@ -58,22 +363,26 @@ function parseEnv(contents) {
   }
   return out;
 }
-function hasSyncConfig() {
-  return existsSync(paths.syncEnv);
+function defaultPath() {
+  return resolveActiveProject().syncEnv;
 }
-function loadSyncConfig() {
-  if (!existsSync(paths.syncEnv))
+function hasSyncConfig(syncEnvPath) {
+  return existsSync3(syncEnvPath ?? defaultPath());
+}
+function loadSyncConfig(syncEnvPath) {
+  const path = syncEnvPath ?? defaultPath();
+  if (!existsSync3(path))
     return null;
-  const mode = statSync(paths.syncEnv).mode & 511;
+  const mode = statSync2(path).mode & 511;
   if (mode & 63) {
-    console.warn(`warning: ${paths.syncEnv} was mode 0${mode.toString(8)} (should be 0600). Tightening to 0600.`);
+    console.warn(`warning: ${path} was mode 0${mode.toString(8)} (should be 0600). Tightening to 0600.`);
     try {
-      chmodSync(paths.syncEnv, 384);
+      chmodSync(path, 384);
     } catch (e) {
       console.warn(`failed to chmod 0600: ${e instanceof Error ? e.message : String(e)}. Fix manually.`);
     }
   }
-  const env = parseEnv(readFileSync(paths.syncEnv, "utf8"));
+  const env = parseEnv(readFileSync2(path, "utf8"));
   if (!env.SUPABASE_URL || !env.SUPABASE_SERVICE_KEY || !env.BERTRAND_SYNC_BUCKET || !env.BERTRAND_ENCRYPTION_KEY) {
     return null;
   }
@@ -86,7 +395,8 @@ function loadSyncConfig() {
     clientName: env.BERTRAND_CLIENT_NAME || `bertrand-${process.platform}-${process.pid}`
   };
 }
-function saveSyncConfig(cfg) {
+function saveSyncConfig(cfg, syncEnvPath) {
+  const path = syncEnvPath ?? defaultPath();
   const lines = [
     "# bertrand sync configuration",
     "# Created by `bertrand sync onboard`. chmod 600.",
@@ -105,13 +415,13 @@ function saveSyncConfig(cfg) {
     `BERTRAND_CLIENT_NAME=${cfg.clientName}`,
     ""
   ];
-  writeFileSync(paths.syncEnv, lines.join(`
+  writeFileSync2(path, lines.join(`
 `), { mode: 384 });
-  chmodSync(paths.syncEnv, 384);
+  chmodSync(path, 384);
 }
 var KEYS;
 var init_config = __esm(() => {
-  init_paths();
+  init_resolve();
   KEYS = [
     "SUPABASE_URL",
     "SUPABASE_SERVICE_KEY",
@@ -123,17 +433,21 @@ var init_config = __esm(() => {
 });
 
 // src/lib/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+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(readFileSync2(CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync3(configPath(), "utf-8"));
   } catch {
     return null;
   }
 }
 function writeConfig(config) {
-  writeFileSync2(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+  mkdirSync3(_getRegistryDir(), { recursive: true });
+  writeFileSync3(configPath(), JSON.stringify(config, null, 2) + `
 `);
 }
 function patchConfig(patch) {
@@ -160,10 +474,8 @@ function isPlainObject(v) {
 function isSyncEnabled() {
   return readConfig()?.sync?.enabled === true;
 }
-var CONFIG_PATH;
 var init_config2 = __esm(() => {
-  init_paths();
-  CONFIG_PATH = join2(paths.root, "config.json");
+  init_registry();
 });
 
 // src/sync/trigger.ts
@@ -191,15 +503,29 @@ var init_trigger = __esm(() => {
 });
 
 // src/cli/router.ts
-import { existsSync as existsSync2 } 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 (existsSync2(paths.db))
+  if (existsSync4(resolveActiveProject().db))
     return;
   const init = commands.get("init");
   if (!init)
@@ -216,6 +542,9 @@ 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();
@@ -252,17 +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
@@ -273,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(),
@@ -293,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(),
@@ -304,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", {
@@ -317,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)
   ]);
@@ -383,25 +723,70 @@ 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 busy_timeout = 5000");
   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 });
+      if (!hasSessionsTable(sqlite)) {
+        sqlite.exec("DROP TABLE IF EXISTS __drizzle_migrations");
+        migrate(db, { migrationsFolder: MIGRATIONS_FOLDER });
+      }
+    } catch (err) {
+      sqlite.close();
+      throw err;
+    }
+    _migrated.add(dbPath);
+  }
+  _cache.set(dbPath, db);
+  return db;
 }
-var _db = null;
+function hasSessionsTable(sqlite) {
+  const row = sqlite.query("SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'").get();
+  return row !== 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
@@ -421,18 +806,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",
@@ -457,6 +842,28 @@ var init_sessions = __esm(() => {
   init_id();
 });
 
+// src/db/queries/conversations.ts
+import { eq as eq2, and as and2, desc, sql as sql3 } from "drizzle-orm";
+function createConversation(opts) {
+  return getDb().insert(conversations).values(opts).returning().get();
+}
+function getConversation(id) {
+  return getDb().select().from(conversations).where(eq2(conversations.id, id)).get();
+}
+function getConversationsBySession(sessionId) {
+  return getDb().select().from(conversations).where(and2(eq2(conversations.sessionId, sessionId), eq2(conversations.discarded, false))).orderBy(desc(conversations.startedAt)).all();
+}
+function endConversation(id) {
+  return getDb().update(conversations).set({ endedAt: sql3`(datetime('now'))` }).where(eq2(conversations.id, id)).returning().get();
+}
+function updateLastQuestion(id, question) {
+  return getDb().update(conversations).set({ lastQuestion: question }).where(eq2(conversations.id, id)).returning().get();
+}
+var init_conversations = __esm(() => {
+  init_client();
+  init_schema();
+});
+
 // src/lib/markdown.ts
 function normalizeMarkdown(input) {
   return input.replace(/\r\n?/g, `
@@ -506,7 +913,7 @@ function normalizeAnsweredMeta(meta) {
 }
 
 // src/db/queries/events.ts
-import { eq as eq2, and as and2, desc } from "drizzle-orm";
+import { eq as eq3, and as and3, desc as desc2 } from "drizzle-orm";
 function insertEvent(opts) {
   return getDb().insert(events).values({
     sessionId: opts.sessionId,
@@ -517,17 +924,27 @@ function insertEvent(opts) {
   }).returning().get();
 }
 function getEventsBySession(sessionId) {
-  return getDb().select().from(events).where(eq2(events.sessionId, sessionId)).orderBy(events.createdAt, events.id).all();
+  return getDb().select().from(events).where(eq3(events.sessionId, sessionId)).orderBy(events.createdAt, events.id).all();
 }
 function getEventsByType(sessionId, eventType) {
-  return getDb().select().from(events).where(and2(eq2(events.sessionId, sessionId), eq2(events.event, eventType))).orderBy(events.createdAt).all();
+  return getDb().select().from(events).where(and3(eq3(events.sessionId, sessionId), eq3(events.event, eventType))).orderBy(events.createdAt).all();
+}
+function getLatestEventOfType(sessionId, eventType, conversationId) {
+  const conditions = [
+    eq3(events.sessionId, sessionId),
+    eq3(events.event, eventType)
+  ];
+  if (conversationId) {
+    conditions.push(eq3(events.conversationId, conversationId));
+  }
+  return getDb().select().from(events).where(and3(...conditions)).orderBy(desc2(events.createdAt)).limit(1).get();
 }
 function getLatestRecaps() {
   const rows = getDb().select({
     sessionId: events.sessionId,
     meta: events.meta,
     createdAt: events.createdAt
-  }).from(events).where(eq2(events.event, "session.recap")).orderBy(desc(events.createdAt)).all();
+  }).from(events).where(eq3(events.event, "session.recap")).orderBy(desc2(events.createdAt)).all();
   const result = {};
   for (const row of rows) {
     if (result[row.sessionId])
@@ -545,37 +962,326 @@ var init_events = __esm(() => {
   init_schema();
 });
 
-// src/db/queries/conversations.ts
-import { eq as eq3, and as and3, desc as desc2, sql as sql3 } from "drizzle-orm";
-function createConversation(opts) {
-  return getDb().insert(conversations).values(opts).returning().get();
+// src/db/events/emit.ts
+function emitSessionStarted(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "session.started",
+    meta: {
+      category_path: args.categoryPath,
+      session_name: args.sessionName,
+      session_slug: args.sessionSlug,
+      labels: args.labels,
+      summary: args.summary ?? null
+    }
+  });
 }
-function getConversation(id) {
-  return getDb().select().from(conversations).where(eq3(conversations.id, id)).get();
+function emitSessionResumed(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "session.resumed",
+    meta: { claude_id: args.conversationId }
+  });
 }
-function getConversationsBySession(sessionId) {
-  return getDb().select().from(conversations).where(and3(eq3(conversations.sessionId, sessionId), eq3(conversations.discarded, false))).orderBy(desc2(conversations.startedAt)).all();
+function emitSessionPaused(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "session.paused",
+    meta: { claude_id: args.conversationId }
+  });
 }
-function endConversation(id) {
-  return getDb().update(conversations).set({ endedAt: sql3`(datetime('now'))` }).where(eq3(conversations.id, id)).returning().get();
+function emitSessionPausedByRecovery(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    event: "session.paused",
+    summary: "Recovered from stale state (process not found)",
+    meta: { stale_pid: args.stalePid }
+  });
 }
-function updateLastQuestion(id, question) {
-  return getDb().update(conversations).set({ lastQuestion: question }).where(eq3(conversations.id, id)).returning().get();
+function emitSessionEnded(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    event: "session.end"
+  });
 }
-var init_conversations = __esm(() => {
-  init_client();
-  init_schema();
+function emitClaudeStarted(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "claude.started",
+    meta: {
+      claude_id: args.conversationId,
+      model: args.model,
+      claude_version: args.claudeVersion,
+      git: args.git,
+      cwd: args.cwd
+    }
+  });
+}
+function emitClaudeEnded(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "claude.ended",
+    meta: { claude_id: args.conversationId, exit_code: args.exitCode }
+  });
+}
+function emitUserPrompted(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "user.prompt",
+    meta: { prompt: args.prompt, claude_id: args.conversationId }
+  });
+}
+function emitSessionWaiting(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "session.waiting",
+    summary: args.question,
+    meta: { question: args.question, claude_id: args.conversationId }
+  });
+}
+function emitSessionAnswered(args) {
+  const joinedAnswers = Object.values(args.answers).map((v) => String(v)).join(", ") || undefined;
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "session.answered",
+    summary: joinedAnswers,
+    meta: {
+      answers: args.answers,
+      annotations: args.annotations ?? {},
+      questions: args.questions ?? [],
+      claude_id: args.conversationId
+    }
+  });
+}
+function emitSessionRecap(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "session.recap",
+    summary: args.recap.slice(0, 200),
+    meta: { recap: args.recap, claude_id: args.conversationId }
+  });
+}
+function emitPermissionRequested(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "permission.request",
+    meta: {
+      tool: args.tool,
+      detail: args.detail,
+      claude_id: args.conversationId
+    }
+  });
+}
+function emitPermissionResolved(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "permission.resolve",
+    meta: {
+      tool: args.tool,
+      detail: args.detail,
+      outcome: args.outcome,
+      claude_id: args.conversationId
+    }
+  });
+}
+function emitToolUsed(args) {
+  const summary = formatToolSummary(args.tool, args.detail);
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "tool.used",
+    summary,
+    meta: {
+      tool: args.tool,
+      detail: args.detail,
+      outcome: args.outcome,
+      claude_id: args.conversationId
+    }
+  });
+}
+function formatToolSummary(tool, detail) {
+  if (!detail)
+    return tool;
+  switch (tool) {
+    case "Bash":
+      return `ran \`${detail.slice(0, 120)}\``;
+    case "Read":
+      return `read ${detail}`;
+    case "Glob":
+    case "Grep":
+      return `${tool.toLowerCase()} ${detail}`;
+    case "TodoWrite":
+      return "updated todos";
+    case "WebFetch":
+      return `fetched ${detail}`;
+    case "WebSearch":
+      return `searched: ${detail}`;
+    default:
+      return `${tool}: ${detail}`;
+  }
+}
+function emitToolApplied(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "tool.applied",
+    summary: args.summary,
+    meta: {
+      permissions: args.permissions,
+      outcome: "applied",
+      claude_id: args.conversationId
+    }
+  });
+}
+function emitAssistantMessage(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "assistant.message",
+    summary: args.summary,
+    meta: {
+      model: args.model,
+      text: args.text,
+      thinkingBlocks: args.thinkingBlocks,
+      thinkingBytes: args.thinkingBytes,
+      claude_id: args.conversationId
+    }
+  });
+}
+function emitAssistantRecap(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "assistant.recap",
+    summary: args.recap.length > 80 ? `${args.recap.slice(0, 77)}...` : args.recap,
+    meta: { recap: args.recap, claude_id: args.conversationId }
+  });
+}
+function emitContextSnapshot(args) {
+  return insertEvent({
+    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    event: "context.snapshot",
+    summary: `${args.remainingPct}% remaining`,
+    meta: {
+      model: args.model,
+      input_tokens: String(args.inputTokens),
+      cache_creation_tokens: String(args.cacheCreationTokens),
+      cache_read_tokens: String(args.cacheReadTokens),
+      context_window_tokens: String(args.totalContextTokens),
+      remaining_pct: String(args.remainingPct),
+      claude_id: args.conversationId
+    }
+  });
+}
+var init_emit = __esm(() => {
+  init_events();
 });
 
 // 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;
+}
+function dispatchHookEvent(event, ctx) {
+  const { sessionId, conversationId, meta, summary } = ctx;
+  switch (event) {
+    case "user.prompt":
+      emitUserPrompted({
+        sessionId,
+        conversationId,
+        prompt: String(meta.prompt ?? "")
+      });
+      return true;
+    case "session.waiting":
+      emitSessionWaiting({
+        sessionId,
+        conversationId,
+        question: String(meta.question ?? "Waiting for input")
+      });
+      return true;
+    case "session.answered":
+      emitSessionAnswered({
+        sessionId,
+        conversationId,
+        answers: meta.answers ?? {},
+        annotations: meta.annotations ?? {},
+        questions: meta.questions ?? []
+      });
+      return true;
+    case "session.recap":
+      emitSessionRecap({
+        sessionId,
+        conversationId,
+        recap: String(meta.recap ?? "")
+      });
+      return true;
+    case "session.paused":
+      emitSessionPaused({ sessionId, conversationId });
+      return true;
+    case "permission.request":
+      emitPermissionRequested({
+        sessionId,
+        conversationId,
+        tool: String(meta.tool ?? ""),
+        detail: String(meta.detail ?? "")
+      });
+      return true;
+    case "permission.resolve":
+      emitPermissionResolved({
+        sessionId,
+        conversationId,
+        tool: String(meta.tool ?? ""),
+        detail: String(meta.detail ?? ""),
+        outcome: meta.outcome === "denied" ? "denied" : "approved"
+      });
+      return true;
+    case "tool.applied":
+      emitToolApplied({
+        sessionId,
+        conversationId,
+        summary: summary ?? "edited a file",
+        permissions: meta.permissions ?? []
+      });
+      return true;
+    case "tool.used":
+      emitToolUsed({
+        sessionId,
+        conversationId,
+        tool: String(meta.tool ?? "Unknown"),
+        detail: String(meta.detail ?? ""),
+        outcome: meta.outcome === "approved" ? "approved" : "auto"
+      });
+      return true;
+    default:
+      return false;
+  }
+}
 var EVENT_STATUS_MAP;
 var init_update = __esm(() => {
   init_router();
   init_sessions();
-  init_events();
   init_conversations();
   init_trigger();
+  init_emit();
   EVENT_STATUS_MAP = {
     "session.waiting": "waiting",
     "session.answered": "active",
@@ -619,7 +1325,8 @@ var init_update = __esm(() => {
     if (newStatus && newStatus === session.status) {
       return;
     }
-    let meta;
+    const ignoreStatusFlip = shouldIgnoreStatusFlip(newStatus, session.pid);
+    let meta = {};
     if (metaJson) {
       try {
         meta = JSON.parse(metaJson);
@@ -630,16 +1337,16 @@ var init_update = __esm(() => {
     }
     const rawConvoId = meta?.claude_id || process.env.BERTRAND_CLAUDE_ID || undefined;
     const conversationId = rawConvoId && getConversation(rawConvoId) ? rawConvoId : undefined;
-    const answersObj = meta?.answers;
-    const joinedAnswers = answersObj ? Object.values(answersObj).join(", ") || undefined : undefined;
-    insertEvent({
+    const dispatched = dispatchHookEvent(event, {
       sessionId,
       conversationId,
-      event,
-      summary: summaryArg || meta?.question || joinedAnswers || undefined,
-      meta
+      meta,
+      summary: summaryArg
     });
-    if (newStatus) {
+    if (!dispatched) {
+      return;
+    }
+    if (newStatus && !ignoreStatusFlip) {
       updateSessionStatus(sessionId, newStatus);
     }
     if (event === "session.waiting" && conversationId && meta?.question) {
@@ -652,7 +1359,7 @@ var init_update = __esm(() => {
 });
 
 // src/lib/transcript.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } 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))
@@ -661,9 +1368,9 @@ function getContextWindowSize(model) {
   return 200000;
 }
 function getLatestAssistantTurn(filePath) {
-  if (!existsSync3(filePath))
+  if (!existsSync5(filePath))
     return null;
-  const text2 = readFileSync3(filePath, "utf-8");
+  const text2 = readFileSync4(filePath, "utf-8");
   const lines = text2.split(`
 `);
   const assistantEntries = [];
@@ -721,9 +1428,9 @@ function getLatestAssistantTurn(filePath) {
   };
 }
 function getContextSnapshot(filePath) {
-  if (!existsSync3(filePath))
+  if (!existsSync5(filePath))
     return null;
-  const text2 = readFileSync3(filePath, "utf-8");
+  const text2 = readFileSync4(filePath, "utf-8");
   const lines = text2.split(`
 `);
   for (let i = lines.length - 1;i >= 0; i--) {
@@ -777,7 +1484,7 @@ var init_snapshot = __esm(() => {
   init_router();
   init_sessions();
   init_conversations();
-  init_events();
+  init_emit();
   init_transcript();
   register("snapshot", async (args) => {
     let sessionId = "";
@@ -810,20 +1517,15 @@ var init_snapshot = __esm(() => {
     if (!snapshot)
       return;
     const convoId = conversationId && getConversation(conversationId) ? conversationId : undefined;
-    insertEvent({
+    emitContextSnapshot({
       sessionId,
       conversationId: convoId,
-      event: "context.snapshot",
-      summary: `${snapshot.remainingPct}% remaining`,
-      meta: {
-        model: snapshot.model,
-        input_tokens: String(snapshot.inputTokens),
-        cache_creation_tokens: String(snapshot.cacheCreationTokens),
-        cache_read_tokens: String(snapshot.cacheReadTokens),
-        context_window_tokens: String(snapshot.totalContextTokens),
-        remaining_pct: String(snapshot.remainingPct),
-        claude_id: convoId
-      }
+      model: snapshot.model,
+      inputTokens: snapshot.inputTokens,
+      cacheCreationTokens: snapshot.cacheCreationTokens,
+      cacheReadTokens: snapshot.cacheReadTokens,
+      totalContextTokens: snapshot.totalContextTokens,
+      remainingPct: snapshot.remainingPct
     });
   });
 });
@@ -836,14 +1538,16 @@ function summarize(text2) {
   const trimmed = firstLine.trim();
   return trimmed.length > 80 ? `${trimmed.slice(0, 77)}...` : trimmed;
 }
-var RECAP_TAG_RE;
+var RECAP_RE, RECAP_TAG_GLOBAL;
 var init_assistant_message = __esm(() => {
   init_router();
   init_sessions();
   init_conversations();
   init_events();
+  init_emit();
   init_transcript();
-  RECAP_TAG_RE = /<recap>[\s\S]*?<\/recap>/gi;
+  RECAP_RE = /<recap>([\s\S]*?)<\/recap>/i;
+  RECAP_TAG_GLOBAL = /<recap>[\s\S]*?<\/recap>/gi;
   register("assistant-message", async (args) => {
     let sessionId = "";
     let transcriptPath = "";
@@ -874,34 +1578,50 @@ var init_assistant_message = __esm(() => {
     const turn = getLatestAssistantTurn(transcriptPath);
     if (!turn)
       return;
-    const text2 = turn.text.replace(RECAP_TAG_RE, "").trim();
+    const fullText = turn.text;
+    const textSansRecap = fullText.replace(RECAP_TAG_GLOBAL, "").trim();
     const convoId = conversationId && getConversation(conversationId) ? conversationId : undefined;
-    insertEvent({
-      sessionId,
-      conversationId: convoId,
-      event: "assistant.message",
-      summary: text2 ? summarize(text2) : "thinking only",
-      meta: {
-        model: turn.model,
-        text: text2,
-        thinkingBlocks: turn.thinkingBlocks,
-        thinkingBytes: turn.thinkingBytes,
-        claude_id: convoId
+    if (textSansRecap || turn.thinkingBlocks > 0) {
+      const latestMsg = getLatestEventOfType(sessionId, "assistant.message", convoId);
+      const latestText = latestMsg?.meta?.text;
+      if (latestText !== textSansRecap) {
+        emitAssistantMessage({
+          sessionId,
+          conversationId: convoId,
+          text: textSansRecap,
+          model: turn.model,
+          thinkingBlocks: turn.thinkingBlocks,
+          thinkingBytes: turn.thinkingBytes,
+          summary: textSansRecap ? summarize(textSansRecap) : "thinking only"
+        });
       }
-    });
+    }
+    const recapMatch = fullText.match(RECAP_RE);
+    const recap = recapMatch?.[1]?.trim();
+    if (recap) {
+      const latestRecap = getLatestEventOfType(sessionId, "assistant.recap", convoId);
+      const latestRecapText = latestRecap?.meta?.recap;
+      if (latestRecapText !== recap) {
+        emitAssistantRecap({
+          sessionId,
+          conversationId: convoId,
+          recap
+        });
+      }
+    }
   });
 });
 
 // src/cli/commands/recap-thinking.ts
 var exports_recap_thinking = {};
-var RECAP_RE;
+var RECAP_RE2;
 var init_recap_thinking = __esm(() => {
   init_router();
   init_sessions();
   init_conversations();
-  init_events();
+  init_emit();
   init_transcript();
-  RECAP_RE = /<recap>([\s\S]*?)<\/recap>/i;
+  RECAP_RE2 = /<recap>([\s\S]*?)<\/recap>/i;
   register("recap-thinking", async (args) => {
     let sessionId = "";
     let transcriptPath = "";
@@ -929,17 +1649,15 @@ var init_recap_thinking = __esm(() => {
     const turn = getLatestAssistantTurn(transcriptPath);
     if (!turn?.text)
       return;
-    const match = turn.text.match(RECAP_RE);
+    const match = turn.text.match(RECAP_RE2);
     const recap = match?.[1]?.trim();
     if (!recap)
       return;
     const convoId = conversationId && getConversation(conversationId) ? conversationId : undefined;
-    insertEvent({
+    emitAssistantRecap({
       sessionId,
       conversationId: convoId,
-      event: "assistant.recap",
-      summary: recap.length > 80 ? `${recap.slice(0, 77)}...` : recap,
-      meta: { recap, claude_id: convoId }
+      recap
     });
   });
 });
@@ -990,8 +1708,8 @@ class NoopAdapter {
 }
 
 // src/terminal/index.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 function getTerminalAdapter() {
   if (cachedAdapter)
     return cachedAdapter;
@@ -1010,7 +1728,7 @@ function getTerminalAdapter() {
 }
 function readConfigTerminal() {
   try {
-    const config = JSON.parse(readFileSync4(join3(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;
@@ -1259,6 +1977,14 @@ function aggregateToolUsage(sessionId) {
       continue;
     counts[tool] = (counts[tool] ?? 0) + 1;
   }
+  const used = getEventsByType(sessionId, "tool.used");
+  for (const ev of used) {
+    const meta = ev.meta;
+    const tool = meta?.tool;
+    if (!tool)
+      continue;
+    counts[tool] = (counts[tool] ?? 0) + 1;
+  }
   return counts;
 }
 function contextTokenStats(sessionId) {
@@ -1349,7 +2075,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 };
 }
@@ -1361,8 +2087,8 @@ var init_session_archive = __esm(() => {
 
 // src/server/index.ts
 import { execFile } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
 function liveStats(sessionId) {
   return {
     sessionId,
@@ -1376,6 +2102,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 {
@@ -1415,11 +2159,11 @@ function match(pathname, url) {
 }
 function findDashboardDir() {
   const candidates = [
-    join4(import.meta.dir, "dashboard"),
-    join4(import.meta.dir, "..", "dashboard")
+    join7(import.meta.dir, "dashboard"),
+    join7(import.meta.dir, "..", "dashboard")
   ];
   for (const dir of candidates) {
-    if (existsSync4(join4(dir, "index.html")))
+    if (existsSync6(join7(dir, "index.html")))
       return dir;
   }
   return null;
@@ -1428,13 +2172,13 @@ async function serveDashboard(pathname) {
   if (!DASHBOARD_DIR)
     return null;
   const requested = pathname === "/" ? "/index.html" : pathname;
-  const filePath = join4(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(join4(DASHBOARD_DIR, "index.html")));
+  return new Response(Bun.file(join7(DASHBOARD_DIR, "index.html")));
 }
 function startServer(port = PORT) {
   const server = Bun.serve({
@@ -1455,6 +2199,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) {
@@ -1517,7 +2266,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();
@@ -1525,6 +2285,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],
@@ -1533,7 +2295,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" },
@@ -1557,36 +2321,41 @@ var init_serve = __esm(() => {
 
 // src/sync/snapshot.ts
 import { Database as Database2 } from "bun:sqlite";
-import { existsSync as existsSync5, unlinkSync } from "fs";
+import { existsSync as existsSync7, unlinkSync } from "fs";
+function snapshotPathFor(dbPath) {
+  return `${dbPath}.sync-snapshot`;
+}
 function takeSnapshot() {
   cleanupSnapshot();
-  const src = new Database2(paths.db, { readonly: true });
+  const dbPath = resolveActiveProject().db;
+  const target = snapshotPathFor(dbPath);
+  const src = new Database2(dbPath, { readonly: true });
   try {
-    src.exec(`VACUUM INTO '${SNAPSHOT_PATH.replace(/'/g, "''")}'`);
+    src.exec(`VACUUM INTO '${target.replace(/'/g, "''")}'`);
   } finally {
     src.close();
   }
-  return SNAPSHOT_PATH;
+  return target;
 }
 function cleanupSnapshot() {
+  const base = snapshotPathFor(resolveActiveProject().db);
   for (const suffix of SIDECAR_SUFFIXES) {
-    const p = SNAPSHOT_PATH + suffix;
-    if (existsSync5(p)) {
+    const p = base + suffix;
+    if (existsSync7(p)) {
       try {
         unlinkSync(p);
       } catch {}
     }
   }
 }
-var SIDECAR_SUFFIXES, SNAPSHOT_PATH;
+var SIDECAR_SUFFIXES;
 var init_snapshot2 = __esm(() => {
-  init_paths();
+  init_resolve();
   SIDECAR_SUFFIXES = ["", "-wal", "-shm"];
-  SNAPSHOT_PATH = `${paths.db}.sync-snapshot`;
 });
 
 // src/sync/crypto.ts
-import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes2 } from "crypto";
 function parseKey(base64Key) {
   const buf = Buffer.from(base64Key, "base64");
   if (buf.length !== 32) {
@@ -1595,11 +2364,11 @@ function parseKey(base64Key) {
   return buf;
 }
 function generateKeyBase64() {
-  return randomBytes(32).toString("base64");
+  return randomBytes2(32).toString("base64");
 }
 function encrypt(plaintext, base64Key) {
   const key = parseKey(base64Key);
-  const iv = randomBytes(IV_LEN);
+  const iv = randomBytes2(IV_LEN);
   const cipher = createCipheriv(ALGO, key, iv);
   const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
   const tag = cipher.getAuthTag();
@@ -1627,9 +2396,8 @@ var init_crypto = __esm(() => {
 
 // src/sync/engine.ts
 import { createClient } from "@supabase/supabase-js";
-import { readFileSync as readFileSync5, renameSync, statSync as statSync2, openSync, writeSync, fsyncSync, closeSync } from "fs";
+import { readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync3, openSync, writeSync, fsyncSync, closeSync } from "fs";
 import { dirname as dirname2 } from "path";
-import { execFileSync } from "child_process";
 function client(cfg) {
   if (!cfg)
     return null;
@@ -1658,7 +2426,7 @@ async function push() {
         error: `snapshot failed: ${e instanceof Error ? e.message : String(e)}`
       };
     }
-    const plaintext = readFileSync5(snapshotPath);
+    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",
@@ -1688,17 +2456,18 @@ async function pull(opts = {}) {
   if (!cfg || !supabase) {
     return { ok: false, operation: "pull", error: "sync config incomplete" };
   }
-  const holders = findHolders(paths.db);
+  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: `${paths.db} is held by ${procs} \u2014 close active bertrand sessions before pulling, ` + `or pass --force to overwrite anyway (risks corrupting the running session).`
+        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 ${paths.db}. The running process may crash on next file access.`);
+    console.warn(`warning: --force pulling while ${procs} hold ${dbPath}. The running process may crash on next file access.`);
   }
   const started = performance.now();
   try {
@@ -1717,7 +2486,7 @@ async function pull(opts = {}) {
     }
     const ciphertext = Buffer.from(await data.arrayBuffer());
     const plaintext = decrypt(ciphertext, cfg.encryptionKey);
-    const tmp = `${paths.db}.pull-${process.pid}`;
+    const tmp = `${dbPath}.pull-${process.pid}`;
     const fd = openSync(tmp, "w");
     try {
       writeSync(fd, plaintext);
@@ -1725,8 +2494,8 @@ async function pull(opts = {}) {
     } finally {
       closeSync(fd);
     }
-    renameSync(tmp, paths.db);
-    const dirFd = openSync(dirname2(paths.db), "r");
+    renameSync3(tmp, dbPath);
+    const dirFd = openSync(dirname2(dbPath), "r");
     try {
       fsyncSync(dirFd);
     } finally {
@@ -1747,9 +2516,10 @@ 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 = statSync2(paths.db);
+    const s = statSync3(dbPath);
     local = { size: s.size, modifiedAt: new Date(s.mtimeMs) };
   } catch {
     local = null;
@@ -1774,48 +2544,25 @@ async function status() {
   }
   return { configured: true, local, remote };
 }
-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_engine = __esm(() => {
-  init_paths();
+  init_resolve();
+  init_lsof();
   init_config();
   init_snapshot2();
   init_crypto();
 });
 
 // src/sync/invite.ts
-function encodeInvite(cfg) {
+function encodeInvite(cfg, project) {
   const bundle = {
     v: VERSION,
     url: cfg.supabaseUrl,
     key: cfg.supabaseServiceKey,
     bucket: cfg.bucket,
     obj: cfg.objectKey,
-    ek: cfg.encryptionKey
+    ek: cfg.encryptionKey,
+    psl: project.slug,
+    pn: project.name
   };
   return SCHEME + Buffer.from(JSON.stringify(bundle), "utf8").toString("base64url");
 }
@@ -1839,22 +2586,125 @@ function decodeInvite(invite) {
   }
   const bundle = parsed;
   if (bundle.v !== VERSION) {
-    throw new Error(`invite version ${String(bundle.v)} is not supported by this bertrand (expected v${VERSION}). ` + `Upgrade or downgrade so both machines run the same 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"]) {
+  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 {
-    supabaseUrl: bundle.url,
-    supabaseServiceKey: bundle.key,
-    bucket: bundle.bucket,
-    objectKey: bundle.obj,
-    encryptionKey: bundle.ek
+    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 busy_timeout = 5000");
+  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 SCHEME = "bertrand-sync://", VERSION = 1;
+var init_bootstrap = __esm(() => {
+  init_config();
+  init_engine();
+  init_registry();
+  init_create();
+  init_resolve();
+  init_config2();
+});
 
 // src/lib/format.ts
 function formatDuration(ms) {
@@ -1912,32 +2762,65 @@ var init_format = __esm(() => {
 
 // src/cli/commands/sync.ts
 var exports_sync = {};
-import { hostname } from "os";
+import { hostname as hostname2 } from "os";
 function printUsage2() {
   console.log(`
-bertrand sync \u2014 replicate your local DB to Supabase Storage (opt-in)
+bertrand sync \u2014 replicate a project's local DB to Supabase Storage (opt-in)
 
 Usage:
-  bertrand sync onboard           Interactive: configure Supabase + bucket + encryption key
-  bertrand sync invite            Print a paste-able bundle for another machine
-  bertrand sync <bundle>          One-liner: decode bundle, save config, pull
-  bertrand sync push              VACUUM \u2192 encrypt \u2192 upload
-  bertrand sync pull [--force]    Download \u2192 decrypt \u2192 atomic-replace (refuses if active)
-  bertrand sync status            Local + remote object size and timestamps
-  bertrand sync enable            Turn auto-triggers on (assumes onboard already ran)
-  bertrand sync disable           Turn auto-triggers off without deleting credentials
+  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 onboards, pulls, ready
+              \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}: `);
@@ -1962,9 +2845,10 @@ function prompt(label, opts = {}) {
   });
 }
 async function runOnboard() {
+  const active = resolveActiveProject();
   const existing = loadSyncConfig();
   if (existing) {
-    console.log(`Existing config at ${paths.syncEnv}:`);
+    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}`);
@@ -1972,10 +2856,10 @@ async function runOnboard() {
     console.log(`  BERTRAND_ENCRYPTION_KEY: (set, redacted)`);
     console.log(`  BERTRAND_CLIENT_NAME:   ${existing.clientName}`);
     console.log(`
-Delete ${paths.syncEnv} and re-run to start over.`);
+Delete ${active.syncEnv} and re-run to start over.`);
     return;
   }
-  console.log(`Bertrand sync setup \u2014 Supabase Storage
+  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`);
@@ -1985,7 +2869,7 @@ Delete ${paths.syncEnv} and re-run to start over.`);
   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("Project ID");
+  const projectId = await prompt("Supabase Project ID");
   if (!projectId)
     return abort("no project ID provided");
   if (!/^[a-z0-9]{15,30}$/i.test(projectId)) {
@@ -2000,8 +2884,9 @@ Delete ${paths.syncEnv} and re-run to start over.`);
     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 objectKey = await prompt("Object key", { default: "bertrand.db.enc" });
-  const defaultName = `bertrand-${hostname()}`;
+  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`);
@@ -2022,7 +2907,7 @@ Encryption key`);
     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 DB:
+    console.log(`other machine that should be able to pull this project:
 `);
     console.log(`  ${encryptionKey}
 `);
@@ -2031,18 +2916,16 @@ Generated a new key. Save this somewhere safe \u2014 you'll need it on every`);
   }
   saveSyncConfig({ supabaseUrl, supabaseServiceKey, bucket, objectKey, encryptionKey, clientName });
   patchConfig({ sync: { enabled: true } });
-  console.log(`Wrote ${paths.syncEnv} (mode 0600). Sync auto-triggers enabled.`);
+  console.log(`Wrote ${active.syncEnv} (mode 0600). Sync auto-triggers enabled.`);
   console.log(`
 Next:`);
-  console.log(`  bertrand sync push      Send your current local DB to Supabase`);
+  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`);
-  console.log(`
-On another machine: paste the same SUPABASE_URL, a fresh SERVICE_KEY (you can reuse),`);
-  console.log(`the same bucket and object key, and the SAME encryption key. Then \`bertrand sync pull\`.`);
 }
 async function runPush() {
   if (!hasSyncConfig())
-    return abort("no sync config \u2014 run `bertrand sync onboard`");
+    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) {
@@ -2055,7 +2938,7 @@ async function runPush() {
 }
 async function runPull(args) {
   if (!hasSyncConfig())
-    return abort("no sync config \u2014 run `bertrand sync onboard`");
+    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 });
@@ -2072,11 +2955,12 @@ async function runPull(args) {
   }
 }
 async function runStatus() {
+  const active = resolveActiveProject();
   if (!hasSyncConfig()) {
-    console.log("Sync is not configured. Run `bertrand sync onboard` to set up.");
+    console.log(`Sync is not configured for project "${active.slug}". Run \`bertrand sync onboard\` to set up.`);
     return;
   }
-  console.log(`Sync status (${paths.syncEnv}):`);
+  console.log(`Sync status for project "${active.slug}" (${active.syncEnv}):`);
   console.log(`  Auto-triggers:       ${isSyncEnabled() ? "enabled" : "disabled"}`);
   const s = await status();
   if (s.local) {
@@ -2092,7 +2976,7 @@ async function runStatus() {
 }
 function runEnable() {
   if (!hasSyncConfig()) {
-    return abort("no sync config \u2014 run `bertrand sync onboard` first");
+    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.");
@@ -2100,44 +2984,39 @@ function runEnable() {
 function runInvite() {
   const cfg = loadSyncConfig();
   if (!cfg) {
-    return abort("no sync config \u2014 run `bertrand sync onboard` first");
+    return abort("no sync config for the active project \u2014 run `bertrand sync onboard` first");
   }
-  const invite = encodeInvite(cfg);
-  console.log("Sensitive: this bundle contains a Supabase service_role token AND your DB encryption key.");
+  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) {
-  if (hasSyncConfig()) {
-    return abort(`sync config already exists at ${paths.syncEnv}. ` + `Delete it first if you really want to overwrite: \`rm ${paths.syncEnv}\``);
-  }
-  let decoded;
-  try {
-    decoded = decodeInvite(invite);
-  } catch (e) {
-    return abort(e instanceof Error ? e.message : String(e));
-  }
-  const clientName = `bertrand-${hostname()}`;
-  saveSyncConfig({ ...decoded, clientName });
-  patchConfig({ sync: { enabled: true } });
-  console.log(`Wrote ${paths.syncEnv} (mode 0600). Auto-triggers enabled.`);
-  console.log(`Pulling\u2026`);
-  const result = await pull();
-  if (result.ok) {
-    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.`);
+  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.error(`Pull failed: ${result.error}`);
-    console.error(`(Config is saved, so you can fix and re-run \`bertrand sync pull\`.)`);
-    process.exit(1);
+    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() {
@@ -2157,7 +3036,9 @@ var init_sync = __esm(() => {
   init_config();
   init_engine();
   init_crypto();
-  init_paths();
+  init_bootstrap();
+  init_registry();
+  init_resolve();
   init_format();
   init_config2();
   register("sync", async (args) => {
@@ -2166,12 +3047,14 @@ var init_sync = __esm(() => {
       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(args.slice(1));
+        await runPull(rest);
         return;
       case "status":
         await runStatus();
@@ -2201,48 +3084,48 @@ var init_sync = __esm(() => {
   });
 });
 
-// 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();
@@ -2299,19 +3182,19 @@ var init_template2 = __esm(() => {
 });
 
 // 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(`
@@ -2336,13 +3219,16 @@ 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 = spawn2("claude", args, {
@@ -2372,8 +3258,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";
@@ -2444,11 +3335,11 @@ var init_spawn_context = __esm(() => {
 
 // src/lib/server-lifecycle.ts
 import { spawn as spawn3 } from "child_process";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2 } from "fs";
+import { join as join8 } from "path";
 function readPidFile() {
   try {
-    const pid = Number(readFileSync6(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;
@@ -2495,7 +3386,7 @@ async function ensureServerStarted() {
   });
   child.unref();
   if (child.pid)
-    writeFileSync3(deps.pidFile, String(child.pid));
+    writeFileSync4(deps.pidFile, String(child.pid));
 }
 function stopServerIfIdle() {
   if (deps.getActiveCount() > 0)
@@ -2513,11 +3404,11 @@ var init_server_lifecycle = __esm(() => {
   init_paths();
   init_sessions();
   defaultDeps = {
-    pidFile: join5(paths.root, "server.pid"),
+    pidFile: join8(paths.root, "server.pid"),
     port: Number(process.env.BERTRAND_PORT ?? 5200),
     resolveBin() {
       try {
-        const config = JSON.parse(readFileSync6(join5(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;
@@ -2530,17 +3421,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
   });
@@ -2554,34 +3480,29 @@ 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}`;
-  insertEvent({
+  const sessionName = `${opts.categoryPath}/${opts.slug}`;
+  emitSessionStarted({
     sessionId: session.id,
     conversationId: claudeId,
-    event: "session.started",
-    meta: {
-      group_path: opts.groupPath,
-      session_name: opts.name ?? opts.slug,
-      session_slug: opts.slug,
-      labels: opts.labelNames ?? [],
-      summary: session.summary ?? null
-    }
+    categoryPath: opts.categoryPath,
+    sessionName: opts.name ?? opts.slug,
+    sessionSlug: opts.slug,
+    labels: opts.labelNames ?? [],
+    summary: session.summary ?? null
   });
-  insertEvent({
+  emitClaudeStarted({
     sessionId: session.id,
     conversationId: claudeId,
-    event: "claude.started",
-    meta: {
-      claude_id: claudeId,
-      model: spawnContext.model,
-      claude_version: spawnContext.claudeVersion,
-      git: spawnContext.git,
-      cwd: spawnContext.cwd
-    }
+    model: spawnContext.model,
+    claudeVersion: spawnContext.claudeVersion,
+    git: spawnContext.git,
+    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,
@@ -2597,18 +3518,18 @@ 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({
+  emitSessionResumed({
     sessionId: session.id,
-    conversationId: opts.conversationId,
-    event: "session.resumed",
-    meta: { claude_id: opts.conversationId }
+    conversationId: 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,
@@ -2629,29 +3550,28 @@ function finalizeSession(sessionId, conversationId, exitCode) {
   if (conversationExists) {
     endConversation(conversationId);
   }
-  insertEvent({
+  emitClaudeEnded({
     sessionId,
     conversationId: safeConversationId,
-    event: "claude.ended",
-    meta: { claude_id: conversationId, exit_code: exitCode }
+    exitCode
   });
   updateSession(sessionId, {
     status: "paused",
     pid: null,
     endedAt: new Date().toISOString()
   });
-  insertEvent({
-    sessionId,
-    event: "session.end"
-  });
+  if (liveSession?.sessionId === sessionId)
+    liveSession = null;
+  emitSessionEnded({ sessionId });
   computeAndPersist(sessionId);
   stopServerIfIdle();
 }
+var liveSession = null, exitHandlersInstalled = false;
 var init_session = __esm(() => {
   init_sessions();
   init_conversations();
-  init_events();
-  init_groups();
+  init_emit();
+  init_categories();
   init_labels();
   init_template2();
   init_context();
@@ -2663,8 +3583,8 @@ var init_session = __esm(() => {
 
 // src/tui/app.tsx
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync7, unlinkSync as unlinkSync3 } from "fs";
-import { join as join6 } from "path";
+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`;
@@ -2677,12 +3597,12 @@ async function runScreen(screen, ...args) {
   if (exitCode !== 0) {
     throw new Error(`TUI screen "${screen}" exited with code ${exitCode}`);
   }
-  const result = JSON.parse(readFileSync7(tmpFile, "utf-8"));
+  const result = JSON.parse(readFileSync8(tmpFile, "utf-8"));
   unlinkSync3(tmpFile);
   return result;
 }
-async function startLaunchTui() {
-  return runScreen("launch");
+async function startStartupTui(skipProjectPicker, initialProjectSlug) {
+  return runScreen("startup", String(skipProjectPicker), initialProjectSlug);
 }
 async function startExitTui(sessionId) {
   return runScreen("exit", sessionId);
@@ -2732,26 +3652,38 @@ async function runSessionLoop(sessionId) {
     }
   }
 }
+function shouldShowProjectPicker() {
+  if (process.env.BERTRAND_PROJECT)
+    return false;
+  const projects = listProjects();
+  return projects.length !== 1;
+}
 async function startTui() {
-  const selection = await startLaunchTui();
+  const skipProjectPicker = !shouldShowProjectPicker();
+  const initialProjectSlug = getActiveProjectSlug();
+  const selection = await startStartupTui(skipProjectPicker, initialProjectSlug);
+  _resetActiveProjectCache();
   switch (selection.type) {
     case "quit":
-      break;
+      return;
     case "create": {
-      const sessionId = await launch(selection);
+      const sessionId = await launch({
+        categoryPath: selection.categoryPath,
+        slug: selection.slug
+      });
       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;
     }
   }
 }
@@ -2761,9 +3693,11 @@ var init_app = __esm(() => {
   init_conversations();
   init_session_archive();
   init_session();
+  init_registry();
+  init_resolve();
   SCREEN_ENTRY = (() => {
-    const built = join6(import.meta.dir, "run-screen.js");
-    return existsSync6(built) ? built : join6(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");
   })();
 });
 
@@ -2775,7 +3709,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)) {
@@ -2783,8 +3717,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
@@ -2805,11 +3739,9 @@ function recoverStaleSessions() {
         status: "paused",
         pid: null
       });
-      insertEvent({
+      emitSessionPausedByRecovery({
         sessionId: session.id,
-        event: "session.paused",
-        summary: "Recovered from stale state (process not found)",
-        meta: { stale_pid: session.pid }
+        stalePid: session.pid
       });
       recovered++;
     }
@@ -2818,7 +3750,7 @@ function recoverStaleSessions() {
 }
 var init_recovery = __esm(() => {
   init_sessions();
-  init_events();
+  init_emit();
 });
 
 // src/cli/commands/launch.ts
@@ -2832,8 +3764,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;
     }
@@ -2841,33 +3773,14 @@ var init_launch = __esm(() => {
   });
 });
 
-// src/db/migrate.ts
-import { Database as Database3 } 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 dirname3 } from "path";
-function runMigrations() {
-  mkdirSync2(dirname3(paths.db), { recursive: true });
-  const sqlite = new Database3(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 quietHelper(bin) {
+  return `bq() { ${bin} "$@" 2>/dev/null || true; }`;
+}
 function waitingScript(bin) {
-  const BIN = bin;
   return `#!/usr/bin/env bash
 # Hook: PreToolUse AskUserQuestion \u2192 enforce multiSelect, mark session as waiting
+${quietHelper(bin)}
 sid="\${BERTRAND_SESSION:-}"
 [ -z "$sid" ] && exit 0
 
@@ -2891,23 +3804,26 @@ question="$(printf '%s' "$input" | grep -o '"question":"[^"]*"' | head -1 | cut
 # Clear working debounce marker so next resume\u2192working transition fires
 rm -f "/tmp/bertrand-working-$sid"
 
-${BIN} update --session-id "$sid" --event session.waiting --meta "$(jq -n --arg q "$question" --arg cid "$cid" '{question:$q, claude_id:$cid}')"
+bq update --session-id "$sid" --event session.waiting --meta "$(jq -n --arg q "$question" --arg cid "$cid" '{question:$q, claude_id:$cid}')"
 
-# Context snapshot \u2014 extract transcript path and capture token usage
+# Context snapshot \u2014 extract transcript path and capture token usage.
+# assistant-message captures the latest turn's text + recap tag in one pass;
+# replaces the older recap-thinking call which only grabbed the recap. Dedup
+# inside the command makes it idempotent vs the matching Stop-time capture,
+# so the same turn never lands twice.
 tpath="$(printf '%s' "$input" | grep -o '"transcript_path":"[^"]*"' | cut -d'"' -f4)"
 if [ -n "$tpath" ]; then
-  ${BIN} snapshot --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
-  ${BIN} recap-thinking --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
+  bq snapshot --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
+  bq assistant-message --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
 fi
 
 # Badge + notify in background \u2014 terminal UI doesn't need to block Claude
-${BIN} badge message-question --color '#e0b956' --priority 20 --beep &
-${BIN} notify bertrand "$question" &
+bq badge message-question --color '#e0b956' --priority 20 --beep &
+bq notify bertrand "$question" &
 wait
 `;
 }
 function answeredScript(bin) {
-  const BIN = bin;
   return `#!/usr/bin/env bash
 # Hook: PostToolUse AskUserQuestion \u2192 mark session as active
 #
@@ -2915,6 +3831,7 @@ function answeredScript(bin) {
 # Claude Code so the agent halts immediately instead of taking another turn.
 # This is the mechanical enforcement of the contract's loop-exit rule \u2014 the
 # contract prose is a soft hint, this JSON is the guarantee.
+${quietHelper(bin)}
 sid="\${BERTRAND_SESSION:-}"
 [ -z "$sid" ] && exit 0
 
@@ -2936,9 +3853,9 @@ meta="$(printf '%s' "$input" | jq --arg cid "$cid" '
 # Concatenate all answer values into a single string for the Done-for-now check.
 done_check="$(printf '%s' "$meta" | jq -r '.answers | to_entries | map(.value | tostring) | join(" ")' 2>/dev/null)"
 
-${BIN} update --session-id "$sid" --event session.answered --meta "$meta"
+bq update --session-id "$sid" --event session.answered --meta "$meta"
 
-${BIN} badge --clear &
+bq badge --clear &
 
 # Halt the agent loop if the user signaled Done for now. The Stop hook
 # (on-done.sh) will fire afterwards and mark the session as paused.
@@ -2951,7 +3868,7 @@ if printf '%s' "$done_check" | grep -q "Done for now"; then
     [.questions[]?.options[]? | select(.label == "Done for now") | .description] | first // empty
   ' 2>/dev/null)"
   if [ -n "$recap" ]; then
-    ${BIN} update --session-id "$sid" --event session.recap       --meta "$(jq -n --arg recap "$recap" --arg cid "$cid" '{recap:$recap, claude_id:$cid}')"
+    bq update --session-id "$sid" --event session.recap       --meta "$(jq -n --arg recap "$recap" --arg cid "$cid" '{recap:$recap, claude_id:$cid}')"
   fi
 
   printf '{"continue": false, "stopReason": "User selected Done for now"}\\n'
@@ -2961,9 +3878,9 @@ wait
 `;
 }
 function activeScript(bin) {
-  const BIN = bin;
   return `#!/usr/bin/env bash
 # Hook: PreToolUse (catch-all) \u2192 flip waiting to active
+${quietHelper(bin)}
 sid="\${BERTRAND_SESSION:-}"
 [ -z "$sid" ] && exit 0
 
@@ -2983,13 +3900,13 @@ ${EXTRACT_TOOL}
 
 touch "$marker"
 cid="\${BERTRAND_CLAUDE_ID:-}"
-${BIN} update --session-id "$sid" --event session.active --meta "$(jq -n --arg cid "$cid" '{claude_id:$cid}')"
+bq update --session-id "$sid" --event session.active --meta "$(jq -n --arg cid "$cid" '{claude_id:$cid}')"
 `;
 }
 function permissionWaitScript(bin) {
-  const BIN = bin;
   return `#!/usr/bin/env bash
 # Hook: PermissionRequest \u2192 mark pending, emit permission.request
+${quietHelper(bin)}
 sid="\${BERTRAND_SESSION:-}"
 [ -z "$sid" ] && exit 0
 
@@ -3008,38 +3925,45 @@ case "$tool" in
 esac
 
 cid="\${BERTRAND_CLAUDE_ID:-}"
-${BIN} update --session-id "$sid" --event permission.request --meta "$(jq -n --arg t "$tool" --arg d "$detail" --arg cid "$cid" '{tool:$t, detail:$d, claude_id:$cid}')"
+bq update --session-id "$sid" --event permission.request --meta "$(jq -n --arg t "$tool" --arg d "$detail" --arg cid "$cid" '{tool:$t, detail:$d, claude_id:$cid}')"
 
 # Badge + notify in background
-${BIN} badge bell-exclamation --color '#ff6b35' --priority 25 --beep &
-${BIN} notify bertrand "Needs permission: $tool" &
+bq badge bell-exclamation --color '#ff6b35' --priority 25 --beep &
+bq notify bertrand "Needs permission: $tool" &
 wait
 `;
 }
 function permissionDoneScript(bin) {
-  const BIN = bin;
   return `#!/usr/bin/env bash
 # Hook: PostToolUse (catch-all)
 #
-# Two flows:
-#   1. Edit/Write/MultiEdit: ALWAYS emit tool.applied with diff, regardless of permission
-#      flow. This is the only way to capture diffs for auto-approved edits \u2014 bertrand
-#      must never require disabling auto-approve to gather data.
-#   2. Other tools: emit permission.resolve only if a PermissionRequest preceded this
-#      (marker exists). Rejected tools never reach PostToolUse, so a request without a
-#      resolve = rejected.
+# Captures every tool call Claude makes. Three event flows:
+#   1. Edit/Write/MultiEdit \u2192 tool.applied with diff payload. Keeps the
+#      existing dashboard diff-renderer happy and is the only place we get
+#      old_string/new_string on auto-approved edits.
+#   2. Tools that went through a permission prompt \u2192 permission.resolve.
+#      The PermissionRequest hook set a marker; we clear it and log the
+#      approval. (Denials never reach PostToolUse, so absence-of-resolve
+#      means the user said no.)
+#   3. Everything else (auto-approved Bash/Read/Grep/Glob/etc.) \u2192 tool.used
+#      with outcome:"auto". Previously this case dropped the call entirely;
+#      now Claude's read-only / shell activity shows up in the timeline.
+${quietHelper(bin)}
 sid="\${BERTRAND_SESSION:-}"
 [ -z "$sid" ] && exit 0
 
 input="$(cat)"
 ${EXTRACT_TOOL}
 
+# Don't double-log: AskUserQuestion has its own waiting/answered events
+[ "$tool" = "AskUserQuestion" ] && exit 0
+
 marker="/tmp/bertrand-perm-pending-$sid"
 had_marker=0
 if [ -f "$marker" ]; then
   had_marker=1
   rm -f "$marker"
-  ${BIN} badge --clear &
+  bq badge --clear &
 fi
 
 cid="\${BERTRAND_CLAUDE_ID:-}"
@@ -3051,10 +3975,6 @@ case "$tool" in
       Write) summary="wrote a file" ;;
       *) summary="edited a file" ;;
     esac
-    # Single jq pass: build meta.permissions[] with diff data so the dashboard renders
-    # via the existing WorkContent path (same shape as collapsed permission events).
-    # Emit camelCase keys (oldStr/newStr/edits) directly so WorkContent reads
-    # meta.permissions[] without going through transforms.ts's snake\u2192camel adapter.
     meta="$(printf '%s' "$input" | jq --arg t "$tool" --arg d "$detail" --arg cid "$cid" '
       {
         permissions: [
@@ -3067,28 +3987,40 @@ case "$tool" in
         claude_id: $cid
       }
     ')"
-    ${BIN} update --session-id "$sid" --event tool.applied --summary "$summary" --meta "$meta"
+    bq update --session-id "$sid" --event tool.applied --summary "$summary" --meta "$meta"
     wait
     exit 0
     ;;
 esac
 
-# Other tools: only emit permission.resolve if there was a real prompt
-[ "$had_marker" = "0" ] && exit 0
-
+# Extract a tool-shaped detail for the timeline summary. Bash gets the
+# command, file tools get the path; everything else falls back to a generic
+# label inside the emit helper.
 detail=""
 case "$tool" in
   Bash) detail="$(printf '%s' "$input" | grep -o '"command":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-1000)" ;;
+  Read|NotebookRead) detail="$(printf '%s' "$input" | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-1000)" ;;
+  Glob) detail="$(printf '%s' "$input" | grep -o '"pattern":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-200)" ;;
+  Grep) detail="$(printf '%s' "$input" | grep -o '"pattern":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-200)" ;;
+  WebFetch) detail="$(printf '%s' "$input" | grep -o '"url":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-300)" ;;
+  WebSearch) detail="$(printf '%s' "$input" | grep -o '"query":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-200)" ;;
 esac
 
-${BIN} update --session-id "$sid" --event permission.resolve --meta "$(jq -n --arg t "$tool" --arg d "$detail" --arg cid "$cid" '{tool:$t, detail:$d, outcome:"approved", claude_id:$cid}')"
+if [ "$had_marker" = "1" ]; then
+  # Prompted-then-approved path. Keep permission.resolve for back-compat
+  # rendering; downstream consumers can migrate to tool.used at their pace.
+  bq update --session-id "$sid" --event permission.resolve --meta "$(jq -n --arg t "$tool" --arg d "$detail" --arg cid "$cid" '{tool:$t, detail:$d, outcome:"approved", claude_id:$cid}')"
+else
+  # Auto-approved path. Without tool.used, these calls were invisible.
+  bq update --session-id "$sid" --event tool.used --meta "$(jq -n --arg t "$tool" --arg d "$detail" --arg cid "$cid" '{tool:$t, detail:$d, outcome:"auto", claude_id:$cid}')"
+fi
 wait
 `;
 }
 function userPromptScript(bin) {
-  const BIN = bin;
   return `#!/usr/bin/env bash
 # Hook: UserPromptSubmit \u2192 record user free-text prompt
+${quietHelper(bin)}
 sid="\${BERTRAND_SESSION:-}"
 [ -z "$sid" ] && exit 0
 
@@ -3098,28 +4030,31 @@ cid="\${BERTRAND_CLAUDE_ID:-}"
 meta="$(printf '%s' "$input" | jq --arg cid "$cid" '{prompt: (.prompt // ""), claude_id: $cid}')"
 [ -z "$meta" ] && exit 0
 
-${BIN} update --session-id "$sid" --event user.prompt --meta "$meta"
+bq update --session-id "$sid" --event user.prompt --meta "$meta"
 `;
 }
 function doneScript(bin) {
-  const BIN = bin;
   return `#!/usr/bin/env bash
 # Hook: Stop \u2192 mark session as paused
+${quietHelper(bin)}
 sid="\${BERTRAND_SESSION:-}"
 [ -z "$sid" ] && exit 0
 
 input="$(cat)"
 cid="\${BERTRAND_CLAUDE_ID:-}"
-${BIN} update --session-id "$sid" --event session.paused --meta "$(jq -n --arg cid "$cid" '{claude_id:$cid}')"
+bq update --session-id "$sid" --event session.paused --meta "$(jq -n --arg cid "$cid" '{claude_id:$cid}')"
 
-# Final context snapshot \u2014 capture token usage at session end
+# Final transcript reads. assistant-message dedups against the most-recent
+# AskUQ-time capture, so a Done-for-now exit (no work between AskUQ and Stop)
+# lands zero new events here; intermediate Stops with fresh assistant output
+# do land new ones.
 tpath="$(printf '%s' "$input" | grep -o '"transcript_path":"[^"]*"' | cut -d'"' -f4)"
 if [ -n "$tpath" ]; then
-  ${BIN} snapshot --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
-  ${BIN} assistant-message --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
+  bq snapshot --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
+  bq assistant-message --session-id "$sid" --transcript-path "$tpath" --conversation-id "$cid" &
 fi
 
-${BIN} badge check --color '#58c142' --priority 10
+bq badge check --color '#58c142' --priority 10
 `;
 }
 var EXTRACT_TOOL = `tool="$(printf '%s' "$input" | grep -o '"tool_name":"[^"]*"' | cut -d'"' -f4)"`, HOOK_SCRIPTS;
@@ -3136,13 +4071,13 @@ var init_scripts = __esm(() => {
 });
 
 // src/hooks/install.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, chmodSync as chmodSync2 } from "fs";
-import { join as join7 } 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 = join7(paths.hooks, filename);
-    writeFileSync4(filePath, scriptFn(bin));
+    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}`);
@@ -3153,8 +4088,8 @@ var init_install = __esm(() => {
 });
 
 // src/hooks/settings.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
-import { join as join8, dirname as dirname4 } 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;
@@ -3162,7 +4097,7 @@ function isBertrandGroup(group) {
 function installHookSettings() {
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync8(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 };
@@ -3171,15 +4106,15 @@ function installHookSettings() {
     merged[eventType] = [...existing, ...bertrandGroups];
   }
   settings.hooks = merged;
-  mkdirSync4(dirname4(SETTINGS_PATH), { recursive: true });
-  writeFileSync5(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 = join8(homedir2(), ".claude", "settings.json");
+  SETTINGS_PATH = join11(homedir2(), ".claude", "settings.json");
   BERTRAND_HOOKS = {
     PreToolUse: [
       {
@@ -3223,8 +4158,8 @@ var init_settings = __esm(() => {
 });
 
 // src/lib/completions.ts
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "fs";
-import { join as join9 } from "path";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync9 } from "fs";
+import { join as join12 } from "path";
 function bashCompletion() {
   return `# bertrand bash completion
 _bertrand() {
@@ -3254,11 +4189,11 @@ function fishCompletion() {
 `;
 }
 function generateCompletions() {
-  const dir = join9(paths.root, "completions");
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync6(join9(dir, "bertrand.bash"), bashCompletion());
-  writeFileSync6(join9(dir, "_bertrand"), zshCompletion());
-  writeFileSync6(join9(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`);
@@ -3274,8 +4209,10 @@ var init_completions = __esm(() => {
     "log",
     "stats",
     "archive",
+    "project",
     "update",
     "serve",
+    "sync",
     "import",
     "completion",
     "badge",
@@ -3285,9 +4222,9 @@ var init_completions = __esm(() => {
 
 // src/cli/commands/init.ts
 var exports_init = {};
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7, chmodSync as chmodSync3 } from "fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync8, chmodSync as chmodSync3 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join10 } from "path";
+import { join as join13 } from "path";
 function detectTerminal() {
   try {
     execSync2("which wsh", { stdio: "ignore" });
@@ -3302,10 +4239,10 @@ function resolveBin() {
     return onPath;
   const entry = process.argv[1];
   if (entry && SOURCE_ENTRY.test(entry)) {
-    const launcherDir = join10(paths.root, "bin");
-    const launcher = join10(launcherDir, "bertrand-dev");
-    mkdirSync6(launcherDir, { recursive: true });
-    writeFileSync7(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)} "$@"
 `);
     chmodSync3(launcher, 493);
@@ -3320,16 +4257,18 @@ var init_init = __esm(() => {
   init_install();
   init_settings();
   init_paths();
+  init_resolve();
   init_completions();
   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(`
@@ -3363,7 +4302,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,
@@ -3403,7 +4342,7 @@ var STATUS_DOTS;
 var init_list = __esm(() => {
   init_router();
   init_sessions();
-  init_groups();
+  init_categories();
   init_stats();
   init_format();
   STATUS_DOTS = {
@@ -3416,17 +4355,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");
       }
@@ -3538,8 +4477,11 @@ var init_catalog = __esm(() => {
     "vercel.deploy": { label: "deployed", category: "integration", color: 245, detailColor: 245, skip: false },
     "user.prompt": { label: "prompt", category: "interaction", color: 36, detailColor: 245, skip: false },
     "context.snapshot": { label: "context", category: "context", color: 245, detailColor: 245, skip: true },
+    "tool.used": { label: "tool", category: "work", color: 214, detailColor: 245, skip: true },
     "tool.work": { label: "tool work", category: "work", color: 214, detailColor: 245, skip: false },
-    "session.recap": { label: "session recap", category: "lifecycle", color: 33, detailColor: 245, skip: false }
+    "session.recap": { label: "session recap", category: "lifecycle", color: 33, detailColor: 245, skip: false },
+    "assistant.message": { label: "claude", category: "interaction", color: 39, detailColor: 245, skip: false },
+    "assistant.recap": { label: "recap", category: "interaction", color: 39, detailColor: 245, skip: false }
   };
   DEFAULT_INFO = {
     label: "unknown",
@@ -3579,7 +4521,7 @@ function collapsePermissions(events2) {
   let i = 0;
   while (i < events2.length) {
     const ev = events2[i];
-    if (ev.event !== "permission.request" && ev.event !== "permission.resolve") {
+    if (!ROLLUP_EVENTS.has(ev.event)) {
       result.push(ev);
       i++;
       continue;
@@ -3587,7 +4529,7 @@ function collapsePermissions(events2) {
     const batch = [];
     while (i < events2.length) {
       const current = events2[i];
-      if (current.event !== "permission.request" && current.event !== "permission.resolve")
+      if (!ROLLUP_EVENTS.has(current.event))
         break;
       batch.push(current);
       i++;
@@ -3596,7 +4538,7 @@ function collapsePermissions(events2) {
       continue;
     const toolCounts = new Map;
     for (const pev of batch) {
-      if (pev.event !== "permission.request")
+      if (pev.event !== "permission.request" && pev.event !== "tool.used")
         continue;
       const meta = pev.meta;
       const tool = meta?.tool ?? "unknown";
@@ -3655,8 +4597,14 @@ function filterSkipped(events2) {
 function compact(events2) {
   return deduplicate(collapsePermissions(repairQAPairs(filterSkipped(events2))));
 }
+var ROLLUP_EVENTS;
 var init_compact = __esm(() => {
   init_catalog();
+  ROLLUP_EVENTS = new Set([
+    "permission.request",
+    "permission.resolve",
+    "tool.used"
+  ]);
 });
 
 // src/cli/commands/log.ts
@@ -3673,10 +4621,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);
@@ -3833,7 +4781,7 @@ var init_log = __esm(() => {
   init_router();
   init_sessions();
   init_events();
-  init_groups();
+  init_categories();
   init_stats();
   init_conversations();
   init_catalog();
@@ -3854,18 +4802,18 @@ 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);
   });
 });
 
@@ -3938,7 +4886,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;
@@ -3948,7 +4896,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) {
@@ -3989,7 +4937,7 @@ var init_stats2 = __esm(() => {
   init_router();
   init_sessions();
   init_stats();
-  init_groups();
+  init_categories();
   init_events();
   init_timing();
   init_format();
@@ -4000,34 +4948,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);
   });
 });
@@ -4042,9 +4990,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.");
   });
@@ -4053,23 +5001,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");
@@ -4082,8 +5030,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"}.`);
@@ -4095,8 +5043,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) {
@@ -4129,6 +5077,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];
@@ -4160,7 +5404,8 @@ if (command && command in hotPath) {
     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_sync(), exports_sync))
+    Promise.resolve().then(() => (init_sync(), exports_sync)),
+    Promise.resolve().then(() => (init_project(), exports_project))
   ]);
 }
 await route(process.argv);