bertrand 0.14.0

package/dist/bertrand.js

@@ -0,0 +1,3222 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+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")
+  };
+});
+
+// src/cli/router.ts
+import { existsSync } from "fs";
+function register(name, handler) {
+  commands.set(name, handler);
+}
+function alias(from, to) {
+  aliases.set(from, to);
+}
+async function autoInitIfFirstRun() {
+  if (existsSync(paths.db))
+    return;
+  const init = commands.get("init");
+  if (!init)
+    return;
+  console.log("Setting up bertrand for first use\u2026");
+  const origLog = console.log;
+  console.log = () => {};
+  try {
+    await init([]);
+  } finally {
+    console.log = origLog;
+  }
+}
+async function route(argv) {
+  const args = argv.slice(2);
+  const command = args[0];
+  if (!command) {
+    await autoInitIfFirstRun();
+    const handler2 = commands.get("launch");
+    if (!handler2)
+      throw new Error("No launch command registered");
+    return handler2(args);
+  }
+  if (!resolveCommand(command)) {
+    console.error(`Unknown command: ${command}`);
+    printUsage();
+    process.exit(1);
+  }
+  const resolved = resolveCommand(command);
+  const handler = commands.get(resolved);
+  return handler(args.slice(1));
+}
+function resolveCommand(name) {
+  if (commands.has(name))
+    return name;
+  const aliased = aliases.get(name);
+  if (aliased && commands.has(aliased))
+    return aliased;
+  return;
+}
+function printUsage() {
+  console.log(`
+bertrand \u2014 multi-session workflow manager for Claude Code
+
+Usage:
+  bertrand                  Launch TUI (or resume named session)
+  bertrand init             Setup wizard
+  bertrand list             Session picker
+  bertrand log <session>    View session log
+  bertrand stats <session>  Session statistics
+  bertrand archive <name>   Archive/unarchive a session
+  bertrand update           Hook-facing state writer (internal)
+  bertrand serve            Start dashboard HTTP server
+`.trim());
+}
+var commands, aliases;
+var init_router = __esm(() => {
+  init_paths();
+  commands = new Map;
+  aliases = new Map;
+});
+
+// src/db/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  worktreeAssociations: () => worktreeAssociations,
+  sessions: () => sessions,
+  sessionStats: () => sessionStats,
+  sessionLabels: () => sessionLabels,
+  labels: () => labels,
+  groups: () => groups,
+  events: () => events,
+  conversations: () => conversations
+});
+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 init_schema = __esm(() => {
+  groups = sqliteTable("groups", {
+    id: text("id").primaryKey(),
+    parentId: text("parent_id").references(() => groups.id, {
+      onDelete: "cascade"
+    }),
+    slug: text("slug").notNull(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    depth: integer("depth").notNull().default(0),
+    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)
+  ]);
+  labels = sqliteTable("labels", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull().unique(),
+    color: text("color"),
+    createdAt: text("created_at").notNull().default(sql`(datetime('now'))`)
+  });
+  sessions = sqliteTable("sessions", {
+    id: text("id").primaryKey(),
+    groupId: text("group_id").notNull().references(() => groups.id, { onDelete: "cascade" }),
+    slug: text("slug").notNull(),
+    name: text("name").notNull(),
+    status: text("status", {
+      enum: ["active", "waiting", "paused", "archived"]
+    }).notNull().default("paused"),
+    summary: text("summary"),
+    pid: integer("pid"),
+    startedAt: text("started_at").notNull().default(sql`(datetime('now'))`),
+    endedAt: text("ended_at"),
+    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),
+    index("sessions_status").on(t.status),
+    index("sessions_started").on(t.startedAt)
+  ]);
+  sessionLabels = sqliteTable("session_labels", {
+    sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    labelId: text("label_id").notNull().references(() => labels.id, { onDelete: "cascade" })
+  }, (t) => [
+    uniqueIndex("sl_pk").on(t.sessionId, t.labelId),
+    index("sl_label").on(t.labelId)
+  ]);
+  conversations = sqliteTable("conversations", {
+    id: text("id").primaryKey(),
+    sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    startedAt: text("started_at").notNull().default(sql`(datetime('now'))`),
+    endedAt: text("ended_at"),
+    discarded: integer("discarded", { mode: "boolean" }).notNull().default(false),
+    lastQuestion: text("last_question"),
+    eventCount: integer("event_count").notNull().default(0)
+  }, (t) => [index("conv_session").on(t.sessionId)]);
+  events = sqliteTable("events", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    conversationId: text("conversation_id").references(() => conversations.id),
+    event: text("event").notNull(),
+    summary: text("summary"),
+    meta: text("meta", { mode: "json" }),
+    createdAt: text("created_at").notNull().default(sql`(datetime('now'))`)
+  }, (t) => [
+    index("ev_session").on(t.sessionId),
+    index("ev_session_event").on(t.sessionId, t.event),
+    index("ev_event_created").on(t.event, t.createdAt),
+    index("ev_conversation").on(t.conversationId)
+  ]);
+  worktreeAssociations = sqliteTable("worktree_associations", {
+    id: text("id").primaryKey(),
+    sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+    branch: text("branch").notNull(),
+    worktreePath: text("worktree_path"),
+    active: integer("active", { mode: "boolean" }).notNull().default(true),
+    enteredAt: text("entered_at").notNull().default(sql`(datetime('now'))`),
+    exitedAt: text("exited_at")
+  }, (t) => [
+    index("wt_session").on(t.sessionId),
+    index("wt_active").on(t.active)
+  ]);
+  sessionStats = sqliteTable("session_stats", {
+    sessionId: text("session_id").primaryKey().references(() => sessions.id, { onDelete: "cascade" }),
+    eventCount: integer("event_count").notNull().default(0),
+    conversationCount: integer("conversation_count").notNull().default(0),
+    interactionCount: integer("interaction_count").notNull().default(0),
+    prCount: integer("pr_count").notNull().default(0),
+    claudeWorkS: integer("claude_work_s").notNull().default(0),
+    userWaitS: integer("user_wait_s").notNull().default(0),
+    activePct: integer("active_pct").notNull().default(0),
+    durationS: integer("duration_s").notNull().default(0),
+    linesAdded: integer("lines_added").notNull().default(0),
+    linesRemoved: integer("lines_removed").notNull().default(0),
+    filesTouched: integer("files_touched").notNull().default(0),
+    updatedAt: text("updated_at").notNull().default(sql`(datetime('now'))`)
+  });
+});
+
+// src/db/client.ts
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+function getDb() {
+  if (_db)
+    return _db;
+  mkdirSync(dirname(paths.db), { recursive: true });
+  const sqlite = new Database(paths.db);
+  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;
+}
+var _db = null;
+var init_client = __esm(() => {
+  init_paths();
+  init_schema();
+});
+
+// src/lib/id.ts
+import { nanoid } from "nanoid";
+function createId(size = 12) {
+  return nanoid(size);
+}
+var init_id = () => {};
+
+// src/db/queries/sessions.ts
+import { eq, and, inArray, sql as sql2 } from "drizzle-orm";
+function createSession(opts) {
+  const db = getDb();
+  const id = createId();
+  return db.insert(sessions).values({ id, ...opts }).returning().get();
+}
+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 getSessionsByGroup(groupId) {
+  return getDb().select().from(sessions).where(eq(sessions.groupId, groupId)).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();
+}
+function getAllSessions(opts) {
+  const db = getDb();
+  const query = db.select({ session: sessions, groupPath: groups.path }).from(sessions).innerJoin(groups, eq(sessions.groupId, groups.id));
+  if (opts?.excludeArchived) {
+    return query.where(inArray(sessions.status, [
+      "active",
+      "waiting",
+      "paused"
+    ])).all();
+  }
+  return query.all();
+}
+function updateSessionStatus(id, status) {
+  return getDb().update(sessions).set({ status, updatedAt: sql2`(datetime('now'))` }).where(eq(sessions.id, id)).returning().get();
+}
+function updateSession(id, data) {
+  return getDb().update(sessions).set({ ...data, updatedAt: sql2`(datetime('now'))` }).where(eq(sessions.id, id)).returning().get();
+}
+function deleteSession(id) {
+  return getDb().delete(sessions).where(eq(sessions.id, id)).run();
+}
+var init_sessions = __esm(() => {
+  init_client();
+  init_schema();
+  init_id();
+});
+
+// src/lib/markdown.ts
+function normalizeMarkdown(input) {
+  return input.replace(/\r\n?/g, `
+`);
+}
+function normalizeEventMeta(eventName, meta) {
+  if (!meta)
+    return meta;
+  switch (eventName) {
+    case "session.recap":
+      return mapStringField(meta, "recap", normalizeMarkdown);
+    case "assistant.message":
+      return mapStringField(meta, "text", normalizeMarkdown);
+    case "session.answered":
+      return normalizeAnsweredMeta(meta);
+    default:
+      return meta;
+  }
+}
+function mapStringField(meta, key, fn) {
+  const value = meta[key];
+  if (typeof value !== "string")
+    return meta;
+  return { ...meta, [key]: fn(value) };
+}
+function normalizeAnsweredMeta(meta) {
+  const out = { ...meta };
+  const answers = meta.answers;
+  if (answers && typeof answers === "object" && !Array.isArray(answers)) {
+    out.answers = Object.fromEntries(Object.entries(answers).map(([k, v]) => [
+      k,
+      typeof v === "string" ? normalizeMarkdown(v) : v
+    ]));
+  }
+  const annotations = meta.annotations;
+  if (annotations && typeof annotations === "object" && !Array.isArray(annotations)) {
+    out.annotations = Object.fromEntries(Object.entries(annotations).map(([k, v]) => {
+      if (!v || typeof v !== "object")
+        return [k, v];
+      const a = v;
+      if (typeof a.notes !== "string")
+        return [k, v];
+      return [k, { ...a, notes: normalizeMarkdown(a.notes) }];
+    }));
+  }
+  return out;
+}
+
+// src/db/queries/events.ts
+import { eq as eq2, and as and2, desc } from "drizzle-orm";
+function insertEvent(opts) {
+  return getDb().insert(events).values({
+    sessionId: opts.sessionId,
+    conversationId: opts.conversationId,
+    event: opts.event,
+    summary: opts.summary,
+    meta: normalizeEventMeta(opts.event, opts.meta)
+  }).returning().get();
+}
+function getEventsBySession(sessionId) {
+  return getDb().select().from(events).where(eq2(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();
+}
+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();
+  const result = {};
+  for (const row of rows) {
+    if (result[row.sessionId])
+      continue;
+    const meta = row.meta;
+    const recap = typeof meta?.recap === "string" ? meta.recap : null;
+    if (!recap)
+      continue;
+    result[row.sessionId] = { recap, createdAt: row.createdAt };
+  }
+  return result;
+}
+var init_events = __esm(() => {
+  init_client();
+  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();
+}
+function getConversation(id) {
+  return getDb().select().from(conversations).where(eq3(conversations.id, id)).get();
+}
+function getConversationsBySession(sessionId) {
+  return getDb().select().from(conversations).where(and3(eq3(conversations.sessionId, sessionId), eq3(conversations.discarded, false))).orderBy(desc2(conversations.startedAt)).all();
+}
+function endConversation(id) {
+  return getDb().update(conversations).set({ endedAt: sql3`(datetime('now'))` }).where(eq3(conversations.id, id)).returning().get();
+}
+function updateLastQuestion(id, question) {
+  return getDb().update(conversations).set({ lastQuestion: question }).where(eq3(conversations.id, id)).returning().get();
+}
+var init_conversations = __esm(() => {
+  init_client();
+  init_schema();
+});
+
+// src/cli/commands/update.ts
+var exports_update = {};
+var EVENT_STATUS_MAP;
+var init_update = __esm(() => {
+  init_router();
+  init_sessions();
+  init_events();
+  init_conversations();
+  EVENT_STATUS_MAP = {
+    "session.waiting": "waiting",
+    "session.answered": "active",
+    "session.active": "active",
+    "session.paused": "paused",
+    "session.started": "active",
+    "session.end": "paused"
+  };
+  register("update", async (args) => {
+    let sessionId = "";
+    let event = "";
+    let metaJson = "";
+    let summaryArg;
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      const next = args[i + 1];
+      if (arg === "--session-id" && next) {
+        sessionId = next;
+        i++;
+      } else if (arg === "--event" && next) {
+        event = next;
+        i++;
+      } else if (arg === "--summary" && next) {
+        summaryArg = next;
+        i++;
+      } else if (arg === "--meta" && next) {
+        metaJson = next;
+        i++;
+      }
+    }
+    if (!sessionId || !event) {
+      console.error("Usage: bertrand update --session-id <id> --event <type> [--meta <json>]");
+      process.exit(1);
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+      console.error(`Session not found: ${sessionId}`);
+      process.exit(1);
+    }
+    const newStatus = EVENT_STATUS_MAP[event];
+    if (newStatus && newStatus === session.status) {
+      return;
+    }
+    let meta;
+    if (metaJson) {
+      try {
+        meta = JSON.parse(metaJson);
+      } catch {
+        console.error(`Invalid JSON meta: ${metaJson}`);
+        process.exit(1);
+      }
+    }
+    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({
+      sessionId,
+      conversationId,
+      event,
+      summary: summaryArg || meta?.question || joinedAnswers || undefined,
+      meta
+    });
+    if (newStatus) {
+      updateSessionStatus(sessionId, newStatus);
+    }
+    if (event === "session.waiting" && conversationId && meta?.question) {
+      updateLastQuestion(conversationId, meta.question);
+    }
+  });
+});
+
+// src/lib/transcript.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+function getContextWindowSize(model) {
+  for (const [prefix, size] of Object.entries(CONTEXT_WINDOW_SIZES)) {
+    if (model.startsWith(prefix))
+      return size;
+  }
+  return 200000;
+}
+function getLatestAssistantTurn(filePath) {
+  if (!existsSync2(filePath))
+    return null;
+  const text2 = readFileSync(filePath, "utf-8");
+  const lines = text2.split(`
+`);
+  const assistantEntries = [];
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type === "user")
+      break;
+    if (entry.type === "assistant")
+      assistantEntries.push(entry);
+  }
+  if (assistantEntries.length === 0)
+    return null;
+  assistantEntries.reverse();
+  let model = "";
+  const textParts = [];
+  let thinkingBlocks = 0;
+  let thinkingBytes = 0;
+  for (const entry of assistantEntries) {
+    const message = entry.message;
+    if (!message)
+      continue;
+    if (message.model)
+      model = message.model;
+    const content = message.content;
+    if (!content)
+      continue;
+    for (const block of content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        textParts.push(block.text);
+      } else if (block.type === "thinking") {
+        thinkingBlocks++;
+        const sig = block.signature;
+        if (typeof sig === "string")
+          thinkingBytes += sig.length;
+      }
+    }
+  }
+  if (textParts.length === 0 && thinkingBlocks === 0)
+    return null;
+  return {
+    model,
+    text: textParts.join(`
+
+`),
+    thinkingBlocks,
+    thinkingBytes
+  };
+}
+function getContextSnapshot(filePath) {
+  if (!existsSync2(filePath))
+    return null;
+  const text2 = readFileSync(filePath, "utf-8");
+  const lines = text2.split(`
+`);
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant")
+      continue;
+    const message = entry.message;
+    const usage = message?.usage;
+    if (!usage)
+      continue;
+    const model = message?.model ?? "";
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
+    const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+    const totalContextTokens = inputTokens + cacheCreationTokens + cacheReadTokens;
+    const windowSize = getContextWindowSize(model);
+    const remainingPct = Math.max(0, Math.min(100, Math.round(100 - totalContextTokens * 100 / windowSize)));
+    return {
+      model,
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens,
+      cacheReadTokens,
+      totalContextTokens,
+      remainingPct
+    };
+  }
+  return null;
+}
+var CONTEXT_WINDOW_SIZES;
+var init_transcript = __esm(() => {
+  CONTEXT_WINDOW_SIZES = {
+    "claude-opus-4": 1e6,
+    "claude-sonnet-4": 200000,
+    "claude-haiku-4": 200000
+  };
+});
+
+// src/cli/commands/snapshot.ts
+var exports_snapshot = {};
+var init_snapshot = __esm(() => {
+  init_router();
+  init_sessions();
+  init_conversations();
+  init_events();
+  init_transcript();
+  register("snapshot", async (args) => {
+    let sessionId = "";
+    let transcriptPath = "";
+    let conversationId = "";
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      const next = args[i + 1];
+      if (arg === "--session-id" && next) {
+        sessionId = next;
+        i++;
+      } else if (arg === "--transcript-path" && next) {
+        transcriptPath = next;
+        i++;
+      } else if (arg === "--conversation-id" && next) {
+        conversationId = next;
+        i++;
+      }
+    }
+    if (!sessionId || !transcriptPath) {
+      console.error("Usage: bertrand snapshot --session-id <id> --transcript-path <path> [--conversation-id <id>]");
+      process.exit(1);
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+      console.error(`Session not found: ${sessionId}`);
+      process.exit(1);
+    }
+    const snapshot = getContextSnapshot(transcriptPath);
+    if (!snapshot)
+      return;
+    const convoId = conversationId && getConversation(conversationId) ? conversationId : undefined;
+    insertEvent({
+      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
+      }
+    });
+  });
+});
+
+// src/cli/commands/assistant-message.ts
+var exports_assistant_message = {};
+function summarize(text2) {
+  const firstLine = text2.split(`
+`).find((l) => l.trim()) ?? "";
+  const trimmed = firstLine.trim();
+  return trimmed.length > 80 ? `${trimmed.slice(0, 77)}...` : trimmed;
+}
+var RECAP_TAG_RE;
+var init_assistant_message = __esm(() => {
+  init_router();
+  init_sessions();
+  init_conversations();
+  init_events();
+  init_transcript();
+  RECAP_TAG_RE = /<recap>[\s\S]*?<\/recap>/gi;
+  register("assistant-message", async (args) => {
+    let sessionId = "";
+    let transcriptPath = "";
+    let conversationId = "";
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      const next = args[i + 1];
+      if (arg === "--session-id" && next) {
+        sessionId = next;
+        i++;
+      } else if (arg === "--transcript-path" && next) {
+        transcriptPath = next;
+        i++;
+      } else if (arg === "--conversation-id" && next) {
+        conversationId = next;
+        i++;
+      }
+    }
+    if (!sessionId || !transcriptPath) {
+      console.error("Usage: bertrand assistant-message --session-id <id> --transcript-path <path> [--conversation-id <id>]");
+      process.exit(1);
+    }
+    const session = getSession(sessionId);
+    if (!session) {
+      console.error(`Session not found: ${sessionId}`);
+      process.exit(1);
+    }
+    const turn = getLatestAssistantTurn(transcriptPath);
+    if (!turn)
+      return;
+    const text2 = turn.text.replace(RECAP_TAG_RE, "").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
+      }
+    });
+  });
+});
+
+// src/cli/commands/recap-thinking.ts
+var exports_recap_thinking = {};
+var RECAP_RE;
+var init_recap_thinking = __esm(() => {
+  init_router();
+  init_sessions();
+  init_conversations();
+  init_events();
+  init_transcript();
+  RECAP_RE = /<recap>([\s\S]*?)<\/recap>/i;
+  register("recap-thinking", async (args) => {
+    let sessionId = "";
+    let transcriptPath = "";
+    let conversationId = "";
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      const next = args[i + 1];
+      if (arg === "--session-id" && next) {
+        sessionId = next;
+        i++;
+      } else if (arg === "--transcript-path" && next) {
+        transcriptPath = next;
+        i++;
+      } else if (arg === "--conversation-id" && next) {
+        conversationId = next;
+        i++;
+      }
+    }
+    if (!sessionId || !transcriptPath) {
+      console.error("Usage: bertrand recap-thinking --session-id <id> --transcript-path <path> [--conversation-id <id>]");
+      process.exit(1);
+    }
+    if (!getSession(sessionId))
+      return;
+    const turn = getLatestAssistantTurn(transcriptPath);
+    if (!turn?.text)
+      return;
+    const match = turn.text.match(RECAP_RE);
+    const recap = match?.[1]?.trim();
+    if (!recap)
+      return;
+    const convoId = conversationId && getConversation(conversationId) ? conversationId : undefined;
+    insertEvent({
+      sessionId,
+      conversationId: convoId,
+      event: "assistant.recap",
+      summary: recap.length > 80 ? `${recap.slice(0, 77)}...` : recap,
+      meta: { recap, claude_id: convoId }
+    });
+  });
+});
+
+// src/terminal/wave.ts
+import { execSync } from "child_process";
+
+class WaveAdapter {
+  type = "wave";
+  detect() {
+    try {
+      execSync("which wsh", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  badge(icon, color, priority = 10, beep = false) {
+    try {
+      const args = ["badge", icon, "--color", color, "--priority", String(priority)];
+      if (beep)
+        args.push("--beep");
+      execSync(`wsh ${args.join(" ")}`, { stdio: "ignore" });
+    } catch {}
+  }
+  clearBadge() {
+    try {
+      execSync("wsh badge --clear", { stdio: "ignore" });
+    } catch {}
+  }
+  notify(title, body) {
+    try {
+      execSync(`wsh notify -t ${JSON.stringify(title)} ${JSON.stringify(body)}`, { stdio: "ignore" });
+    } catch {}
+  }
+}
+var init_wave = () => {};
+
+// src/terminal/noop.ts
+class NoopAdapter {
+  type = "noop";
+  detect() {
+    return true;
+  }
+  badge() {}
+  clearBadge() {}
+  notify() {}
+}
+
+// src/terminal/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function getTerminalAdapter() {
+  if (cachedAdapter)
+    return cachedAdapter;
+  const configType = readConfigTerminal();
+  if (configType === "wave") {
+    cachedAdapter = new WaveAdapter;
+    return cachedAdapter;
+  }
+  const wave = new WaveAdapter;
+  if (wave.detect()) {
+    cachedAdapter = wave;
+    return cachedAdapter;
+  }
+  cachedAdapter = new NoopAdapter;
+  return cachedAdapter;
+}
+function readConfigTerminal() {
+  try {
+    const config = JSON.parse(readFileSync2(join2(paths.root, "config.json"), "utf-8"));
+    return config.terminal ?? null;
+  } catch {
+    return null;
+  }
+}
+var cachedAdapter = null;
+var init_terminal = __esm(() => {
+  init_wave();
+  init_paths();
+});
+
+// src/cli/commands/badge.ts
+var exports_badge = {};
+var init_badge = __esm(() => {
+  init_router();
+  init_terminal();
+  register("badge", async (args) => {
+    const adapter = getTerminalAdapter();
+    if (args.includes("--clear")) {
+      adapter.clearBadge();
+      return;
+    }
+    const icon = args[0];
+    if (!icon)
+      return;
+    const colorIdx = args.indexOf("--color");
+    const color = colorIdx >= 0 ? args[colorIdx + 1] ?? "#ffffff" : "#ffffff";
+    const priorityIdx = args.indexOf("--priority");
+    const priority = priorityIdx >= 0 ? parseInt(args[priorityIdx + 1] ?? "10") : 10;
+    const beep = args.includes("--beep");
+    adapter.badge(icon, color, priority, beep);
+  });
+});
+
+// src/cli/commands/notify.ts
+var exports_notify = {};
+var init_notify = __esm(() => {
+  init_router();
+  init_terminal();
+  register("notify", async (args) => {
+    const adapter = getTerminalAdapter();
+    const title = args[0] ?? "bertrand";
+    const body = args.slice(1).join(" ");
+    if (body) {
+      adapter.notify(title, body);
+    }
+  });
+});
+
+// src/db/queries/stats.ts
+import { eq as eq4, sql as sql4 } from "drizzle-orm";
+function getSessionStats(sessionId) {
+  return getDb().select().from(sessionStats).where(eq4(sessionStats.sessionId, sessionId)).get();
+}
+function upsertSessionStats(sessionId, data) {
+  return getDb().insert(sessionStats).values({
+    sessionId,
+    ...data,
+    updatedAt: sql4`(datetime('now'))`
+  }).onConflictDoUpdate({
+    target: sessionStats.sessionId,
+    set: { ...data, updatedAt: sql4`(datetime('now'))` }
+  }).returning().get();
+}
+var init_stats = __esm(() => {
+  init_client();
+  init_schema();
+});
+
+// src/lib/diff_stats.ts
+function lineCount(s) {
+  if (!s)
+    return 0;
+  return s.split(`
+`).length;
+}
+function computeDiffStats(sessionId) {
+  const applied = getEventsByType(sessionId, "tool.applied");
+  const files = new Set;
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  for (const ev of applied) {
+    const meta = ev.meta;
+    const permissions = meta?.permissions ?? [];
+    for (const p of permissions) {
+      if (p.detail)
+        files.add(p.detail);
+      if (p.edits && p.edits.length > 0) {
+        for (const e of p.edits) {
+          linesRemoved += lineCount(e.oldStr);
+          linesAdded += lineCount(e.newStr);
+        }
+      } else {
+        linesRemoved += lineCount(p.oldStr);
+        linesAdded += lineCount(p.newStr);
+      }
+    }
+  }
+  return { linesAdded, linesRemoved, filesTouched: files.size };
+}
+var init_diff_stats = __esm(() => {
+  init_events();
+});
+
+// src/lib/timing.ts
+function getClaudeId(row) {
+  if (row.conversationId)
+    return row.conversationId;
+  const meta = row.meta;
+  return meta?.claude_id ?? undefined;
+}
+function tsMs(iso) {
+  return new Date(iso).getTime();
+}
+function pushSegment(segments, type, startIso, endIso, claudeId) {
+  const durationMs = tsMs(endIso) - tsMs(startIso);
+  if (durationMs <= 0)
+    return;
+  segments.push({ start: startIso, end: endIso, durationMs, type, claudeId });
+}
+function computeTimings(events2) {
+  const segments = [];
+  let state = "idle";
+  let periodStart = null;
+  let currentClaudeId;
+  for (const ev of events2) {
+    switch (ev.event) {
+      case "claude.started": {
+        if (state === "active" && periodStart) {
+          pushSegment(segments, "claude_work", periodStart, ev.createdAt, currentClaudeId);
+        }
+        if (state === "waiting" && periodStart) {
+          pushSegment(segments, "user_wait", periodStart, ev.createdAt, currentClaudeId);
+        }
+        state = "active";
+        periodStart = ev.createdAt;
+        currentClaudeId = getClaudeId(ev);
+        break;
+      }
+      case "session.waiting": {
+        if (state === "active" && periodStart) {
+          pushSegment(segments, "claude_work", periodStart, ev.createdAt, currentClaudeId);
+        }
+        state = "waiting";
+        periodStart = ev.createdAt;
+        currentClaudeId = getClaudeId(ev) ?? currentClaudeId;
+        break;
+      }
+      case "session.answered": {
+        if (state === "waiting" && periodStart) {
+          pushSegment(segments, "user_wait", periodStart, ev.createdAt, currentClaudeId);
+        }
+        state = "active";
+        periodStart = ev.createdAt;
+        currentClaudeId = getClaudeId(ev) ?? currentClaudeId;
+        break;
+      }
+      case "claude.ended": {
+        if (state === "active" && periodStart) {
+          pushSegment(segments, "claude_work", periodStart, ev.createdAt, currentClaudeId);
+        }
+        if (state === "waiting" && periodStart) {
+          pushSegment(segments, "user_wait", periodStart, ev.createdAt, currentClaudeId);
+        }
+        state = "idle";
+        periodStart = null;
+        currentClaudeId = undefined;
+        break;
+      }
+    }
+  }
+  const lastEvent = events2[events2.length - 1];
+  if (state !== "idle" && periodStart && lastEvent) {
+    if (state === "active") {
+      pushSegment(segments, "claude_work", periodStart, lastEvent.createdAt, currentClaudeId);
+    } else if (state === "waiting") {
+      pushSegment(segments, "user_wait", periodStart, lastEvent.createdAt, currentClaudeId);
+    }
+  }
+  const totalClaudeWorkMs = segments.filter((s) => s.type === "claude_work").reduce((sum, s) => sum + s.durationMs, 0);
+  const totalUserWaitMs = segments.filter((s) => s.type === "user_wait").reduce((sum, s) => sum + s.durationMs, 0);
+  const totalTracked = totalClaudeWorkMs + totalUserWaitMs;
+  const activePct = totalTracked > 0 ? Math.round(totalClaudeWorkMs / totalTracked * 100) : 0;
+  let durationS = 0;
+  if (events2.length >= 2) {
+    const first = tsMs(events2[0].createdAt);
+    const last = tsMs(events2[events2.length - 1].createdAt);
+    durationS = Math.round((last - first) / 1000);
+  }
+  return { totalClaudeWorkMs, totalUserWaitMs, activePct, durationS, segments };
+}
+function computeSessionStats(sessionId) {
+  const events2 = getEventsBySession(sessionId);
+  const summary = computeTimings(events2);
+  const prEvents = getEventsByType(sessionId, "gh.pr.created");
+  const conversationIds = new Set(events2.filter((e) => e.conversationId).map((e) => e.conversationId));
+  const interactionCount = events2.filter((e) => e.event === "session.waiting" || e.event === "session.answered").length;
+  const diff = computeDiffStats(sessionId);
+  return {
+    eventCount: events2.length,
+    conversationCount: conversationIds.size,
+    interactionCount,
+    prCount: prEvents.length,
+    claudeWorkS: Math.round(summary.totalClaudeWorkMs / 1000),
+    userWaitS: Math.round(summary.totalUserWaitMs / 1000),
+    activePct: summary.activePct,
+    durationS: summary.durationS,
+    linesAdded: diff.linesAdded,
+    linesRemoved: diff.linesRemoved,
+    filesTouched: diff.filesTouched
+  };
+}
+function computeAndPersist(sessionId) {
+  const data = computeSessionStats(sessionId);
+  upsertSessionStats(sessionId, data);
+  return data;
+}
+function computeTimingsLive(sessionId) {
+  return computeTimings(getEventsBySession(sessionId));
+}
+var init_timing = __esm(() => {
+  init_events();
+  init_stats();
+  init_diff_stats();
+});
+
+// src/lib/engagement_stats.ts
+import { eq as eq5, sql as sql5 } from "drizzle-orm";
+function aggregateToolUsage(sessionId) {
+  const counts = {};
+  const applied = getEventsByType(sessionId, "tool.applied");
+  for (const ev of applied) {
+    const meta = ev.meta;
+    const permissions = meta?.permissions ?? [];
+    for (const p of permissions) {
+      if (!p.tool)
+        continue;
+      counts[p.tool] = (counts[p.tool] ?? 0) + (p.count ?? 1);
+    }
+  }
+  const resolves = getEventsByType(sessionId, "permission.resolve");
+  for (const ev of resolves) {
+    const meta = ev.meta;
+    const tool = meta?.tool;
+    if (!tool)
+      continue;
+    counts[tool] = (counts[tool] ?? 0) + 1;
+  }
+  return counts;
+}
+function contextTokenStats(sessionId) {
+  const snapshots = getEventsByType(sessionId, "context.snapshot");
+  const samples = [];
+  for (const ev of snapshots) {
+    const meta = ev.meta;
+    const total = parseInt(meta?.context_window_tokens ?? "0", 10);
+    if (Number.isFinite(total) && total > 0)
+      samples.push(total);
+  }
+  if (samples.length === 0)
+    return { avg: 0, max: 0, latest: 0 };
+  let sum = 0;
+  let max = 0;
+  for (const n of samples) {
+    sum += n;
+    if (n > max)
+      max = n;
+  }
+  const avg = Math.round(sum / samples.length);
+  const latest = samples[samples.length - 1] ?? 0;
+  return { avg, max, latest };
+}
+function permissionDenialCount(sessionId) {
+  const all = getEventsBySession(sessionId);
+  let requests = 0;
+  let resolves = 0;
+  for (const ev of all) {
+    if (ev.event === "permission.request")
+      requests++;
+    else if (ev.event === "permission.resolve")
+      resolves++;
+  }
+  return Math.max(0, requests - resolves);
+}
+function discardRate(sessionId) {
+  const row = getDb().select({
+    total: sql5`count(*)`,
+    discarded: sql5`sum(case when ${conversations.discarded} then 1 else 0 end)`
+  }).from(conversations).where(eq5(conversations.sessionId, sessionId)).get();
+  return {
+    total: row?.total ?? 0,
+    discarded: row?.discarded ?? 0
+  };
+}
+function computeEngagementStats(sessionId) {
+  return {
+    toolUsage: aggregateToolUsage(sessionId),
+    contextTokens: contextTokenStats(sessionId),
+    permissionDenials: permissionDenialCount(sessionId),
+    discardRate: discardRate(sessionId)
+  };
+}
+var init_engagement_stats = __esm(() => {
+  init_client();
+  init_schema();
+  init_events();
+});
+
+// src/server/index.ts
+import { execFile } from "child_process";
+async function handleOpen(req) {
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+  const path = body.path;
+  if (typeof path !== "string" || !path.startsWith("/")) {
+    return Response.json({ error: "path must be an absolute string" }, { status: 400 });
+  }
+  return new Promise((resolve) => {
+    execFile("open", [path], (err) => {
+      if (err) {
+        resolve(Response.json({ error: err.message }, { status: 500 }));
+        return;
+      }
+      resolve(Response.json({ ok: true }));
+    });
+  });
+}
+function match(pathname, url) {
+  for (const [pattern, handler] of routes) {
+    const m = pattern.exec(pathname);
+    if (!m)
+      continue;
+    try {
+      const result = handler(m.groups ?? {}, url);
+      return Response.json(result ?? null);
+    } catch (err) {
+      console.error(`[server] ${pathname} failed:`, err);
+      const message = err instanceof Error ? err.message : "Internal server error";
+      return Response.json({ error: message }, { status: 500 });
+    }
+  }
+  return Response.json({ error: "Not found" }, { status: 404 });
+}
+function startServer(port = PORT) {
+  const server = Bun.serve({
+    port,
+    fetch(req) {
+      const url = new URL(req.url);
+      if (req.method === "OPTIONS") {
+        return new Response(null, {
+          headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type"
+          }
+        });
+      }
+      if (req.method === "POST" && url.pathname === "/api/open") {
+        return handleOpen(req).then((r) => {
+          r.headers.set("Access-Control-Allow-Origin", "*");
+          return r;
+        });
+      }
+      const response = match(url.pathname, url);
+      response.headers.set("Access-Control-Allow-Origin", "*");
+      return response;
+    }
+  });
+  console.log(`bertrand API server listening on http://localhost:${server.port}`);
+  return server;
+}
+var PORT, routes;
+var init_server = __esm(() => {
+  init_sessions();
+  init_events();
+  init_stats();
+  init_timing();
+  init_engagement_stats();
+  PORT = Number(process.env.BERTRAND_PORT ?? 5200);
+  routes = [
+    [/^\/api\/sessions$/, (_params, url) => {
+      const excludeArchived = url.searchParams.get("excludeArchived") !== "false";
+      return getAllSessions({ excludeArchived });
+    }],
+    [/^\/api\/sessions\/(?<id>[^/]+)$/, ({ id }) => {
+      return getSession(id);
+    }],
+    [/^\/api\/events\/(?<sessionId>[^/]+)$/, ({ sessionId }, url) => {
+      const eventType = url.searchParams.get("type");
+      if (eventType)
+        return getEventsByType(sessionId, eventType);
+      return getEventsBySession(sessionId);
+    }],
+    [/^\/api\/stats$/, () => {
+      const all = getAllSessions();
+      const now = new Date().toISOString();
+      const result = {};
+      for (const { session } of all) {
+        const isLive = session.status === "active" || session.status === "waiting";
+        if (isLive) {
+          result[session.id] = { sessionId: session.id, ...computeSessionStats(session.id), updatedAt: now };
+          continue;
+        }
+        const stored = getSessionStats(session.id);
+        result[session.id] = stored ?? { sessionId: session.id, ...computeSessionStats(session.id), updatedAt: now };
+      }
+      return result;
+    }],
+    [/^\/api\/stats\/(?<sessionId>[^/]+)$/, ({ sessionId }) => {
+      const session = getSession(sessionId);
+      if (!session)
+        return null;
+      const isLive = session.status === "active" || session.status === "waiting";
+      if (isLive) {
+        return { sessionId, ...computeSessionStats(sessionId), updatedAt: new Date().toISOString() };
+      }
+      const stored = getSessionStats(sessionId);
+      if (stored)
+        return stored;
+      return { sessionId, ...computeSessionStats(sessionId), updatedAt: new Date().toISOString() };
+    }],
+    [/^\/api\/engagement\/(?<sessionId>[^/]+)$/, ({ sessionId }) => {
+      return computeEngagementStats(sessionId);
+    }],
+    [/^\/api\/recaps$/, () => {
+      return getLatestRecaps();
+    }]
+  ];
+});
+
+// src/cli/commands/serve.ts
+var exports_serve = {};
+var init_serve = __esm(() => {
+  init_router();
+  init_server();
+  register("serve", async () => {
+    startServer();
+    await new Promise(() => {});
+  });
+});
+
+// src/db/queries/groups.ts
+import { eq as eq6, like, or, isNull } from "drizzle-orm";
+function createGroup(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();
+    if (!parent)
+      throw new Error(`Parent group ${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();
+}
+function getGroup(id) {
+  return getDb().select().from(groups).where(eq6(groups.id, id)).get();
+}
+function getGroupByPath(path) {
+  return getDb().select().from(groups).where(eq6(groups.path, path)).get();
+}
+function getOrCreateGroupPath(path) {
+  const existing = getGroupByPath(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;
+    } else {
+      const slug = segments[i];
+      const created = createGroup({ slug, name: slug, parentId });
+      parentId = created.id;
+    }
+  }
+  return parentId;
+}
+var init_groups = __esm(() => {
+  init_client();
+  init_schema();
+  init_id();
+});
+
+// src/db/queries/labels.ts
+import { eq as eq7, and as and4 } from "drizzle-orm";
+function createLabel(opts) {
+  return getDb().insert(labels).values({ id: createId(), ...opts }).returning().get();
+}
+function getLabelByName(name) {
+  return getDb().select().from(labels).where(eq7(labels.name, name)).get();
+}
+function getOrCreateLabelByName(name) {
+  const existing = getLabelByName(name);
+  if (existing)
+    return existing;
+  return createLabel({ name });
+}
+function addLabelToSession(sessionId, labelId) {
+  return getDb().insert(sessionLabels).values({ sessionId, labelId }).onConflictDoNothing().returning().get();
+}
+var init_labels = __esm(() => {
+  init_client();
+  init_schema();
+  init_id();
+});
+
+// src/contract/template.md
+var template_default = `You are running inside bertrand, session: {sessionName}. Follow these rules strictly:
+
+At session start, run: ToolSearch with query "select:AskUserQuestion" to load the tool.
+
+After every response, you MUST call AskUserQuestion. This is a continuous loop \u2014 every turn ends with AskUserQuestion. Always include a "Done for now" option so the user can exit the loop when ready. The description for "Done for now" must be a 1-2 sentence summary of what was accomplished so far. Describe outcomes (what was built, fixed, decided), not process.
+
+If the user's most recent answer to AskUserQuestion was "Done for now" (or contains it), this turn is the FINAL turn. Respond briefly to acknowledge and do NOT call AskUserQuestion again \u2014 the loop is over.
+
+Every option must be a concrete, actionable next step. No filler like "Have questions?" or "Want to learn more?" \u2014 if clarification is needed, phrase it as a specific action: "Discuss tradeoffs of X vs Y".
+
+Every AskUserQuestion call MUST use multiSelect: true. No exceptions. Single-select fires on Enter with no confirmation, which causes accidental selections when a block gains focus. multiSelect requires explicit confirmation before submitting.
+
+Before each AskUserQuestion call, emit a \`<recap>...</recap>\` block in your text output. Use markdown \u2014 a short bullet list is usually the most scannable shape; a single short paragraph is fine when the turn was one cohesive thing. Keep it concise. The recap covers what happened since the previous AskUserQuestion (or session start) \u2014 what you found, decided, or did. Write the gist for someone reading the session timeline, not a process log. The dashboard renders these between AskUserQuestion events; do not use this tag for any other purpose.
+`;
+var init_template = () => {};
+
+// src/contract/template.ts
+function buildContract(sessionName, ...contextLayers) {
+  const base = template_default.replace("{sessionName}", sessionName);
+  const layers = contextLayers.map((c) => c.trim()).filter((c) => c.length > 0);
+  if (layers.length === 0)
+    return base;
+  return base + `
+
+` + layers.join(`
+
+`);
+}
+var init_template2 = __esm(() => {
+  init_template();
+});
+
+// src/lib/format.ts
+function formatDuration(ms) {
+  if (ms < MINUTE)
+    return `${Math.round(ms / SECOND)}s`;
+  const days = Math.floor(ms / DAY);
+  const hours = Math.floor(ms % DAY / HOUR);
+  const minutes = Math.floor(ms % HOUR / MINUTE);
+  if (days > 0)
+    return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+  if (hours > 0)
+    return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+  return `${minutes}m`;
+}
+function formatAgo(isoOrDate) {
+  const date = typeof isoOrDate === "string" ? new Date(isoOrDate) : isoOrDate;
+  const ms = Date.now() - date.getTime();
+  if (ms < MINUTE)
+    return "just now";
+  if (ms < HOUR)
+    return `${Math.floor(ms / MINUTE)}m ago`;
+  if (ms < DAY)
+    return `${Math.floor(ms / HOUR)}h ago`;
+  if (ms < 2 * DAY)
+    return "yesterday";
+  if (ms < 7 * DAY)
+    return `${Math.floor(ms / DAY)}d ago`;
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function truncate(text2, maxLen) {
+  if (text2.length <= maxLen)
+    return text2;
+  return text2.slice(0, maxLen - 1) + "\u2026";
+}
+function formatTime(iso, includeDate = false) {
+  const date = new Date(iso);
+  const time = date.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit"
+  });
+  if (!includeDate)
+    return time;
+  const day = date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric"
+  });
+  return `${day} ${time}`;
+}
+var SECOND = 1000, MINUTE, HOUR, DAY;
+var init_format = __esm(() => {
+  MINUTE = 60 * SECOND;
+  HOUR = 60 * MINUTE;
+  DAY = 24 * HOUR;
+});
+
+// src/contract/context.ts
+function buildSiblingContext(groupId, groupPath, currentSessionId) {
+  const siblings = getSessionsByGroup(groupId).filter((s) => s.id !== currentSessionId);
+  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})`;
+  });
+  const guidance = [
+    "",
+    "To inspect any sibling session's full record, run:",
+    "  bertrand log <group>/<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(`
+`);
+  return `## Sibling Sessions
+${lines.join(`
+`)}
+${guidance}`;
+}
+var init_context = __esm(() => {
+  init_sessions();
+  init_format();
+});
+
+// src/engine/process.ts
+import { spawn } from "child_process";
+function launchClaude(opts) {
+  const args = [];
+  if (opts.resume) {
+    args.push("--resume", opts.claudeId);
+  } else {
+    args.push("--session-id", opts.claudeId);
+  }
+  args.push("--append-system-prompt", opts.contract);
+  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
+  };
+  return new Promise((resolve, reject) => {
+    const child = spawn("claude", args, {
+      env,
+      stdio: "inherit",
+      shell: false
+    });
+    activeChild = child;
+    const onSignal = (signal) => {
+      if (child.pid && !child.killed) {
+        child.kill(signal);
+      }
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    child.on("error", (err) => {
+      activeChild = null;
+      process.removeListener("SIGINT", onSignal);
+      process.removeListener("SIGTERM", onSignal);
+      reject(new Error(`Failed to launch claude: ${err.message}`));
+    });
+    child.on("exit", (code) => {
+      activeChild = null;
+      process.removeListener("SIGINT", onSignal);
+      process.removeListener("SIGTERM", onSignal);
+      resolve(code ?? 0);
+    });
+  });
+}
+var activeChild = null;
+var init_process = () => {};
+
+// src/engine/spawn-context.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify } from "util";
+function captureModel() {
+  return process.env.BERTRAND_MODEL || process.env.CLAUDE_MODEL || undefined;
+}
+async function captureClaudeVersion() {
+  if (cachedClaudeVersion !== null)
+    return cachedClaudeVersion;
+  try {
+    const { stdout } = await execFileAsync("claude", ["--version"], {
+      timeout: 5000
+    });
+    const match2 = stdout.trim().match(/(\d+\.\d+\.\d+(?:\.\d+)?)/);
+    cachedClaudeVersion = match2 ? match2[1] : stdout.trim() || undefined;
+    return cachedClaudeVersion;
+  } catch {
+    cachedClaudeVersion = undefined;
+    return;
+  }
+}
+async function captureGit() {
+  try {
+    const [statusRes, shaRes] = await Promise.all([
+      execFileAsync("git", ["status", "--porcelain=v2", "--branch"], {
+        timeout: 5000
+      }),
+      execFileAsync("git", ["rev-parse", "HEAD"], { timeout: 5000 })
+    ]);
+    let branch;
+    let dirty = false;
+    for (const line of statusRes.stdout.split(`
+`)) {
+      if (line.startsWith("# branch.head ")) {
+        branch = line.slice("# branch.head ".length).trim();
+      } else if (line && !line.startsWith("#")) {
+        dirty = true;
+      }
+    }
+    if (!branch)
+      return;
+    return {
+      branch,
+      sha: shaRes.stdout.trim(),
+      dirty
+    };
+  } catch {
+    return;
+  }
+}
+async function captureSpawnContext() {
+  const [claudeVersion, git] = await Promise.all([
+    captureClaudeVersion(),
+    captureGit()
+  ]);
+  return {
+    model: captureModel(),
+    claudeVersion,
+    git,
+    cwd: process.cwd()
+  };
+}
+var execFileAsync, cachedClaudeVersion = null;
+var init_spawn_context = __esm(() => {
+  execFileAsync = promisify(execFile2);
+});
+
+// src/engine/session.ts
+import { randomUUID } from "crypto";
+async function launch(opts) {
+  const existingGroup = getGroupByPath(opts.groupPath);
+  if (existingGroup) {
+    const existing = getSessionByGroupSlug(existingGroup.id, opts.slug);
+    if (existing) {
+      throw new Error(`Session "${opts.slug}" already exists in group "${opts.groupPath}"`);
+    }
+  }
+  const groupId = getOrCreateGroupPath(opts.groupPath);
+  const session = createSession({
+    groupId,
+    slug: opts.slug,
+    name: opts.name ?? opts.slug
+  });
+  for (const name of opts.labelNames ?? []) {
+    const label = getOrCreateLabelByName(name);
+    addLabelToSession(session.id, label.id);
+  }
+  const claudeId = randomUUID();
+  const conversation = createConversation({
+    id: claudeId,
+    sessionId: session.id
+  });
+  updateSession(session.id, { status: "active", pid: process.pid });
+  const spawnContext = await captureSpawnContext();
+  const sessionName = `${opts.groupPath}/${opts.slug}`;
+  insertEvent({
+    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
+    }
+  });
+  insertEvent({
+    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
+    }
+  });
+  const siblingContext = buildSiblingContext(groupId, opts.groupPath, session.id);
+  const contract = buildContract(sessionName, siblingContext);
+  const exitCode = await launchClaude({
+    sessionId: session.id,
+    claudeId,
+    sessionName,
+    sessionSlug: opts.slug,
+    contract
+  });
+  finalizeSession(session.id, claudeId, exitCode);
+  return session.id;
+}
+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;
+  updateSession(session.id, { status: "active", pid: process.pid });
+  insertEvent({
+    sessionId: session.id,
+    conversationId: opts.conversationId,
+    event: "session.resumed",
+    meta: { claude_id: opts.conversationId }
+  });
+  const groupPath = group?.path ?? "";
+  const siblingContext = buildSiblingContext(session.groupId, groupPath, session.id);
+  const contract = buildContract(sessionName, siblingContext);
+  const exitCode = await launchClaude({
+    sessionId: session.id,
+    claudeId: opts.conversationId,
+    sessionName,
+    sessionSlug: session.slug,
+    contract,
+    resume: true
+  });
+  finalizeSession(session.id, opts.conversationId, exitCode);
+  return session.id;
+}
+function finalizeSession(sessionId, conversationId, exitCode) {
+  if (!getSession(sessionId))
+    return;
+  const conversationExists = !!getConversation(conversationId);
+  const safeConversationId = conversationExists ? conversationId : undefined;
+  if (conversationExists) {
+    endConversation(conversationId);
+  }
+  insertEvent({
+    sessionId,
+    conversationId: safeConversationId,
+    event: "claude.ended",
+    meta: { claude_id: conversationId, exit_code: exitCode }
+  });
+  updateSession(sessionId, {
+    status: "paused",
+    pid: null,
+    endedAt: new Date().toISOString()
+  });
+  insertEvent({
+    sessionId,
+    event: "session.end"
+  });
+  computeAndPersist(sessionId);
+}
+var init_session = __esm(() => {
+  init_sessions();
+  init_conversations();
+  init_events();
+  init_groups();
+  init_labels();
+  init_template2();
+  init_context();
+  init_process();
+  init_spawn_context();
+  init_timing();
+});
+
+// src/tui/app.tsx
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3, unlinkSync } from "fs";
+import { join as join3 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+async function runScreen(screen, ...args) {
+  const tmpFile = `/tmp/bertrand-tui-${process.pid}-${Date.now()}.json`;
+  const child = spawn2("bun", ["run", SCREEN_ENTRY, screen, tmpFile, ...args], {
+    stdio: "inherit"
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.on("exit", (code) => resolve(code ?? 1));
+  });
+  if (exitCode !== 0) {
+    throw new Error(`TUI screen "${screen}" exited with code ${exitCode}`);
+  }
+  const result = JSON.parse(readFileSync3(tmpFile, "utf-8"));
+  unlinkSync(tmpFile);
+  return result;
+}
+async function startLaunchTui() {
+  return runScreen("launch");
+}
+async function startExitTui(sessionId) {
+  return runScreen("exit", sessionId);
+}
+async function startResumeTui(sessionId) {
+  const conversations2 = getConversationsBySession(sessionId);
+  if (conversations2.length === 1) {
+    return { type: "conversation", conversationId: conversations2[0].id };
+  }
+  if (conversations2.length === 0) {
+    return { type: "new" };
+  }
+  return runScreen("resume", sessionId);
+}
+async function resolveConversationForResume(sessionId) {
+  const selection = await startResumeTui(sessionId);
+  switch (selection.type) {
+    case "conversation":
+      return selection.conversationId;
+    case "new": {
+      const id = randomUUID2();
+      createConversation({ id, sessionId });
+      return id;
+    }
+    case "back":
+      return null;
+  }
+}
+async function runSessionLoop(sessionId) {
+  const action = await startExitTui(sessionId);
+  switch (action) {
+    case "save":
+      break;
+    case "archive":
+      updateSessionStatus(sessionId, "archived");
+      break;
+    case "discard":
+      deleteSession(sessionId);
+      break;
+    case "resume": {
+      const conversationId = await resolveConversationForResume(sessionId);
+      if (!conversationId)
+        break;
+      await resume({ sessionId, conversationId });
+      await runSessionLoop(sessionId);
+      break;
+    }
+  }
+}
+async function startTui() {
+  const selection = await startLaunchTui();
+  switch (selection.type) {
+    case "quit":
+      break;
+    case "create": {
+      const sessionId = await launch(selection);
+      await runSessionLoop(sessionId);
+      break;
+    }
+    case "resume": {
+      const sessionId = await resume(selection);
+      await runSessionLoop(sessionId);
+      break;
+    }
+    case "pick": {
+      const conversationId = await resolveConversationForResume(selection.sessionId);
+      if (!conversationId)
+        break;
+      const sessionId = await resume({
+        sessionId: selection.sessionId,
+        conversationId
+      });
+      await runSessionLoop(sessionId);
+      break;
+    }
+  }
+}
+var SCREEN_ENTRY;
+var init_app = __esm(() => {
+  init_sessions();
+  init_conversations();
+  init_session();
+  SCREEN_ENTRY = (() => {
+    const built = join3(import.meta.dir, "run-screen.js");
+    return existsSync3(built) ? built : join3(import.meta.dir, "run-screen.tsx");
+  })();
+});
+
+// src/lib/parse-session-name.ts
+function parseSessionName(input) {
+  const trimmed = input.trim().replace(/^\/+|\/+$/g, "");
+  if (!trimmed) {
+    throw new Error("Session name cannot be empty");
+  }
+  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}")`);
+  }
+  for (const segment of segments) {
+    if (!/^[a-z0-9][a-z0-9._-]*$/i.test(segment)) {
+      throw new Error(`Invalid segment "${segment}": must start with alphanumeric and contain only letters, digits, dots, underscores, or dashes`);
+    }
+  }
+  const slug = segments[segments.length - 1];
+  const groupPath = segments.slice(0, -1).join("/");
+  return { groupPath, slug };
+}
+
+// src/engine/recovery.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function recoverStaleSessions() {
+  const active = getActiveSessions();
+  let recovered = 0;
+  for (const { session } of active) {
+    if (session.pid && !isProcessAlive(session.pid)) {
+      updateSession(session.id, {
+        status: "paused",
+        pid: null
+      });
+      insertEvent({
+        sessionId: session.id,
+        event: "session.paused",
+        summary: "Recovered from stale state (process not found)",
+        meta: { stale_pid: session.pid }
+      });
+      recovered++;
+    }
+  }
+  return recovered;
+}
+var init_recovery = __esm(() => {
+  init_sessions();
+  init_events();
+});
+
+// src/cli/commands/launch.ts
+var exports_launch = {};
+var init_launch = __esm(() => {
+  init_router();
+  init_app();
+  init_session();
+  init_recovery();
+  register("launch", async (args) => {
+    recoverStaleSessions();
+    const sessionName = args[0];
+    if (sessionName) {
+      const { groupPath, slug } = parseSessionName(sessionName);
+      const sessionId = await launch({ groupPath, slug });
+      await runSessionLoop(sessionId);
+      return;
+    }
+    await startTui();
+  });
+});
+
+// src/db/migrate.ts
+import { Database as Database2 } from "bun:sqlite";
+import { drizzle as drizzle2 } from "drizzle-orm/bun-sqlite";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+function runMigrations() {
+  mkdirSync2(dirname2(paths.db), { recursive: true });
+  const sqlite = new Database2(paths.db);
+  sqlite.exec("PRAGMA journal_mode = WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  const db = drizzle2(sqlite);
+  migrate(db, { migrationsFolder: MIGRATIONS_FOLDER });
+  sqlite.close();
+}
+var MIGRATIONS_FOLDER;
+var init_migrate = __esm(() => {
+  init_paths();
+  MIGRATIONS_FOLDER = import.meta.dir + "/migrations";
+  if (false) {}
+});
+
+// src/hooks/scripts.ts
+function waitingScript(bin) {
+  const BIN = bin;
+  return `#!/usr/bin/env bash
+# Hook: PreToolUse AskUserQuestion \u2192 mark session as waiting
+sid="\${BERTRAND_SESSION:-}"
+[ -z "$sid" ] && exit 0
+
+input="$(cat)"
+cid="\${BERTRAND_CLAUDE_ID:-}"
+
+# Extract question \u2014 grep for simple field extraction (~1ms vs jq ~15ms)
+question="$(printf '%s' "$input" | grep -o '"question":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-2000)"
+[ -z "$question" ] && question="Waiting for input"
+
+# 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}')"
+
+# Context snapshot \u2014 extract transcript path and capture token usage
+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" &
+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" &
+wait
+`;
+}
+function answeredScript(bin) {
+  const BIN = bin;
+  return `#!/usr/bin/env bash
+# Hook: PostToolUse AskUserQuestion \u2192 mark session as active
+#
+# If the user's answer contains "Done for now", emit {"continue": false} to
+# 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.
+sid="\${BERTRAND_SESSION:-}"
+[ -z "$sid" ] && exit 0
+
+input="$(cat)"
+cid="\${BERTRAND_CLAUDE_ID:-}"
+
+# Capture the full AskUserQuestion payload so the UI can render picked vs
+# unpicked options alongside the user's answer. tool_input.questions carries
+# the question definitions (label/description/multiSelect) the agent passed.
+meta="$(printf '%s' "$input" | jq --arg cid "$cid" '
+  {
+    answers: ((.tool_input.answers // .tool_response.answers) // {}),
+    annotations: ((.tool_input.annotations // .tool_response.annotations) // {}),
+    questions: (.tool_input.questions // []),
+    claude_id: $cid
+  }
+' 2>/dev/null)"
+
+# 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"
+
+${BIN} 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.
+if printf '%s' "$done_check" | grep -q "Done for now"; then
+  # Promote the picked Done-for-now option's description into a session.recap
+  # event so the timeline has a dedicated end-of-session summary row. Bertrand
+  # forces session exit before Claude can write a closing message, so this
+  # reuses the agent-authored recap that already lives on the option.
+  recap="$(printf '%s' "$meta" | jq -r '
+    [.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}')"
+  fi
+
+  printf '{"continue": false, "stopReason": "User selected Done for now"}\\n'
+fi
+
+wait
+`;
+}
+function activeScript(bin) {
+  const BIN = bin;
+  return `#!/usr/bin/env bash
+# Hook: PreToolUse (catch-all) \u2192 flip waiting to active
+sid="\${BERTRAND_SESSION:-}"
+[ -z "$sid" ] && exit 0
+
+# Debounce: skip if we already sent session.active within the last 5 seconds.
+# This avoids spawning bertrand (~31ms) on every tool call during rapid sequences.
+marker="/tmp/bertrand-working-$sid"
+if [ -f "$marker" ]; then
+  age=$(( $(date +%s) - $(stat -f%m "$marker" 2>/dev/null || echo 0) ))
+  [ "$age" -lt 5 ] && exit 0
+fi
+
+input="$(cat)"
+${EXTRACT_TOOL}
+
+# AskUserQuestion has its own PreToolUse hook
+[ "$tool" = "AskUserQuestion" ] && exit 0
+
+touch "$marker"
+cid="\${BERTRAND_CLAUDE_ID:-}"
+${BIN} 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
+sid="\${BERTRAND_SESSION:-}"
+[ -z "$sid" ] && exit 0
+
+input="$(cat)"
+${EXTRACT_TOOL}
+[ "$tool" = "AskUserQuestion" ] && exit 0
+
+# Write marker so PostToolUse knows this was a real permission prompt (not auto-approved)
+touch "/tmp/bertrand-perm-pending-$sid"
+
+# Extract detail from tool_input via grep (avoid jq for simple fields)
+detail=""
+case "$tool" in
+  Bash) detail="$(printf '%s' "$input" | grep -o '"command":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-1000)" ;;
+  Edit|Write|Read) detail="$(printf '%s' "$input" | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-1000)" ;;
+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}')"
+
+# Badge + notify in background
+${BIN} badge bell-exclamation --color '#ff6b35' --priority 25 --beep &
+${BIN} 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.
+sid="\${BERTRAND_SESSION:-}"
+[ -z "$sid" ] && exit 0
+
+input="$(cat)"
+${EXTRACT_TOOL}
+
+marker="/tmp/bertrand-perm-pending-$sid"
+had_marker=0
+if [ -f "$marker" ]; then
+  had_marker=1
+  rm -f "$marker"
+  ${BIN} badge --clear &
+fi
+
+cid="\${BERTRAND_CLAUDE_ID:-}"
+
+case "$tool" in
+  Edit|Write|MultiEdit)
+    detail="$(printf '%s' "$input" | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-1000)"
+    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: [
+          {tool:$t, detail:$d, outcome:"applied", count:1}
+          + (.tool_input.old_string | if type == "string" and . != "" then {oldStr: .[:4096]} else {} end)
+          + ((.tool_input.new_string // .tool_input.content) | if type == "string" and . != "" then {newStr: .[:4096]} else {} end)
+          + (.tool_input.edits | if type == "array" and length > 0 then {edits: [.[] | {oldStr: ((.old_string // "")[:4096]), newStr: ((.new_string // "")[:4096])}]} else {} end)
+        ],
+        outcome: "applied",
+        claude_id: $cid
+      }
+    ')"
+    ${BIN} 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
+
+detail=""
+case "$tool" in
+  Bash) detail="$(printf '%s' "$input" | grep -o '"command":"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-1000)" ;;
+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}')"
+wait
+`;
+}
+function userPromptScript(bin) {
+  const BIN = bin;
+  return `#!/usr/bin/env bash
+# Hook: UserPromptSubmit \u2192 record user free-text prompt
+sid="\${BERTRAND_SESSION:-}"
+[ -z "$sid" ] && exit 0
+
+input="$(cat)"
+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"
+`;
+}
+function doneScript(bin) {
+  const BIN = bin;
+  return `#!/usr/bin/env bash
+# Hook: Stop \u2192 mark session as paused
+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}')"
+
+# Final context snapshot \u2014 capture token usage at session end
+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" &
+fi
+
+${BIN} badge check --color '#58c142' --priority 10
+`;
+}
+var EXTRACT_TOOL = `tool="$(printf '%s' "$input" | grep -o '"tool_name":"[^"]*"' | cut -d'"' -f4)"`, HOOK_SCRIPTS;
+var init_scripts = __esm(() => {
+  HOOK_SCRIPTS = {
+    "on-waiting.sh": waitingScript,
+    "on-answered.sh": answeredScript,
+    "on-active.sh": activeScript,
+    "on-permission-wait.sh": permissionWaitScript,
+    "on-permission-done.sh": permissionDoneScript,
+    "on-user-prompt.sh": userPromptScript,
+    "on-done.sh": doneScript
+  };
+});
+
+// src/hooks/install.ts
+import { mkdirSync as mkdirSync3, writeFileSync, chmodSync } from "fs";
+import { join as join4 } from "path";
+function installHookScripts(bin) {
+  mkdirSync3(paths.hooks, { recursive: true });
+  for (const [filename, scriptFn] of Object.entries(HOOK_SCRIPTS)) {
+    const filePath = join4(paths.hooks, filename);
+    writeFileSync(filePath, scriptFn(bin));
+    chmodSync(filePath, 493);
+  }
+  console.log(`Installed ${Object.keys(HOOK_SCRIPTS).length} hook scripts to ${paths.hooks}`);
+}
+var init_install = __esm(() => {
+  init_paths();
+  init_scripts();
+});
+
+// src/hooks/settings.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync4 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { homedir as homedir2 } from "os";
+function isBertrandGroup(group) {
+  return group.hooks?.some((h) => h.command?.includes(".bertrand/hooks/")) ?? false;
+}
+function installHookSettings() {
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync4(SETTINGS_PATH, "utf-8"));
+  } catch {}
+  const existingHooks = settings.hooks && typeof settings.hooks === "object" && !Array.isArray(settings.hooks) ? settings.hooks : {};
+  const merged = { ...existingHooks };
+  for (const [eventType, bertrandGroups] of Object.entries(BERTRAND_HOOKS)) {
+    const existing = (merged[eventType] ?? []).filter((g) => !isBertrandGroup(g));
+    merged[eventType] = [...existing, ...bertrandGroups];
+  }
+  settings.hooks = merged;
+  mkdirSync4(dirname3(SETTINGS_PATH), { recursive: true });
+  writeFileSync2(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 = join5(homedir2(), ".claude", "settings.json");
+  BERTRAND_HOOKS = {
+    PreToolUse: [
+      {
+        matcher: "AskUserQuestion",
+        hooks: [{ type: "command", command: `${paths.hooks}/on-waiting.sh` }]
+      },
+      {
+        matcher: "",
+        hooks: [{ type: "command", command: `${paths.hooks}/on-active.sh` }]
+      }
+    ],
+    PostToolUse: [
+      {
+        matcher: "AskUserQuestion",
+        hooks: [{ type: "command", command: `${paths.hooks}/on-answered.sh` }]
+      },
+      {
+        matcher: "",
+        hooks: [{ type: "command", command: `${paths.hooks}/on-permission-done.sh` }]
+      }
+    ],
+    PermissionRequest: [
+      {
+        matcher: "",
+        hooks: [{ type: "command", command: `${paths.hooks}/on-permission-wait.sh` }]
+      }
+    ],
+    Stop: [
+      {
+        matcher: "",
+        hooks: [{ type: "command", command: `${paths.hooks}/on-done.sh` }]
+      }
+    ],
+    UserPromptSubmit: [
+      {
+        matcher: "",
+        hooks: [{ type: "command", command: `${paths.hooks}/on-user-prompt.sh` }]
+      }
+    ]
+  };
+});
+
+// src/lib/completions.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync5 } from "fs";
+import { join as join6 } from "path";
+function bashCompletion() {
+  return `# bertrand bash completion
+_bertrand() {
+  local cur=\${COMP_WORDS[COMP_CWORD]}
+  COMPREPLY=( $(compgen -W "${COMMANDS.join(" ")}" -- "$cur") )
+}
+complete -F _bertrand bertrand
+`;
+}
+function zshCompletion() {
+  return `#compdef bertrand
+# bertrand zsh completion
+_bertrand() {
+  local -a commands
+  commands=(
+${COMMANDS.map((c) => `    '${c}:${c} command'`).join(`
+`)}
+  )
+  _describe 'command' commands
+}
+_bertrand "$@"
+`;
+}
+function fishCompletion() {
+  return COMMANDS.map((c) => `complete -c bertrand -n '__fish_use_subcommand' -a '${c}' -d '${c} command'`).join(`
+`) + `
+`;
+}
+function generateCompletions() {
+  const dir = join6(paths.root, "completions");
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync3(join6(dir, "bertrand.bash"), bashCompletion());
+  writeFileSync3(join6(dir, "_bertrand"), zshCompletion());
+  writeFileSync3(join6(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`);
+  console.log(`    zsh:  fpath=(${dir} $fpath) && compinit`);
+  console.log(`    fish: cp ${dir}/bertrand.fish ~/.config/fish/completions/`);
+}
+var COMMANDS;
+var init_completions = __esm(() => {
+  init_paths();
+  COMMANDS = [
+    "init",
+    "list",
+    "log",
+    "stats",
+    "archive",
+    "update",
+    "serve",
+    "import",
+    "completion",
+    "badge",
+    "notify"
+  ];
+});
+
+// src/cli/commands/init.ts
+var exports_init = {};
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, chmodSync as chmodSync2 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join7 } from "path";
+function detectTerminal() {
+  try {
+    execSync2("which wsh", { stdio: "ignore" });
+    return "wave";
+  } catch {
+    return "other";
+  }
+}
+function writeConfig(config) {
+  writeFileSync4(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+`);
+}
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync5(CONFIG_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function resolveBin() {
+  const onPath = Bun.which("bertrand");
+  if (onPath)
+    return onPath;
+  const entry = process.argv[1];
+  if (entry && SOURCE_ENTRY.test(entry)) {
+    const launcherDir = join7(paths.root, "bin");
+    const launcher = join7(launcherDir, "bertrand-dev");
+    mkdirSync6(launcherDir, { recursive: true });
+    writeFileSync4(launcher, `#!/usr/bin/env bash
+exec ${process.execPath} ${JSON.stringify(entry)} "$@"
+`);
+    chmodSync2(launcher, 493);
+    return launcher;
+  }
+  return null;
+}
+var CONFIG_PATH, SOURCE_ENTRY;
+var init_init = __esm(() => {
+  init_router();
+  init_migrate();
+  init_install();
+  init_settings();
+  init_paths();
+  init_completions();
+  CONFIG_PATH = join7(paths.root, "config.json");
+  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}`);
+    const bin = resolveBin();
+    if (!bin) {
+      console.error(`
+Error: couldn't locate the bertrand binary on PATH.
+` + `Install it globally first:
+` + `  bun i -g bertrand    # or: npm i -g bertrand
+` + "Then re-run `bertrand init`.");
+      process.exit(1);
+    }
+    console.log(`  Bin:      ${bin}`);
+    const existing = readConfig();
+    const terminal = existing?.terminal ?? detectTerminal();
+    const config = {
+      ...existing,
+      terminal,
+      bin,
+      version: 1
+    };
+    writeConfig(config);
+    console.log(`  Terminal: ${terminal}${existing?.terminal ? "" : " (auto-detected)"}`);
+    installHookScripts(bin);
+    installHookSettings();
+    generateCompletions();
+    console.log("\nDone. Run `bertrand` to get started.");
+  });
+});
+
+// src/cli/commands/list.ts
+var exports_list = {};
+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}`,
+      status: row.session.status,
+      updatedAt: row.session.updatedAt,
+      conversations: stats?.conversationCount ?? 0,
+      duration: stats?.durationS ? formatDuration(stats.durationS * 1000) : "-"
+    };
+  });
+}
+function renderTable(rows) {
+  if (rows.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+  const maxName = Math.max(...rows.map((r) => r.name.length), 4);
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  console.log(`${dim}${"  "} ${"NAME".padEnd(maxName)}  ${"STATUS".padEnd(10)}  ${"DURATION".padEnd(8)}  ${"CONVOS".padEnd(6)}  LAST ACTIVE${reset}`);
+  for (const row of rows) {
+    const dot = STATUS_DOTS[row.status] ?? "?";
+    const statusText = row.status.padEnd(10);
+    const dur = row.duration.padEnd(8);
+    const convos = String(row.conversations).padEnd(6);
+    const ago = formatAgo(row.updatedAt);
+    console.log(`${dot} ${row.name.padEnd(maxName)}  ${statusText}  ${dur}  ${convos}  ${ago}`);
+  }
+}
+function renderJson(rows) {
+  const data = rows.map((r) => ({
+    name: r.name,
+    status: r.status,
+    duration: r.duration,
+    conversations: r.conversations,
+    updatedAt: r.updatedAt
+  }));
+  console.log(JSON.stringify(data, null, 2));
+}
+var STATUS_DOTS;
+var init_list = __esm(() => {
+  init_router();
+  init_sessions();
+  init_groups();
+  init_stats();
+  init_format();
+  STATUS_DOTS = {
+    active: "\x1B[32m\u25CF\x1B[0m",
+    waiting: "\x1B[33m\u25CF\x1B[0m",
+    paused: "\x1B[90m\u25CF\x1B[0m",
+    archived: "\x1B[90m\u25CB\x1B[0m"
+  };
+  alias("ls", "list");
+  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;
+    let sessionRows;
+    if (groupPath) {
+      const group = getGroupByPath(groupPath);
+      if (!group) {
+        console.error(`Group not found: ${groupPath}`);
+        process.exit(1);
+      }
+      const groupSessions = getSessionsByGroup(group.id);
+      sessionRows = groupSessions.map((s) => ({ session: s, groupPath: group.path }));
+      if (!showAll) {
+        sessionRows = sessionRows.filter((r) => r.session.status !== "archived");
+      }
+    } else {
+      sessionRows = getAllSessions(showAll ? undefined : { excludeArchived: true });
+    }
+    const rows = buildRows(sessionRows);
+    if (isJson) {
+      renderJson(rows);
+    } else {
+      renderTable(rows);
+    }
+  });
+});
+
+// src/lib/catalog.ts
+function lookup(eventType) {
+  return catalog[eventType] ?? DEFAULT_INFO;
+}
+function extractClaudeId(row) {
+  if (row.conversationId)
+    return row.conversationId;
+  const meta = row.meta;
+  return meta?.claude_id ?? undefined;
+}
+function extractSummary(row) {
+  if (row.summary)
+    return row.summary;
+  const meta = row.meta;
+  if (!meta)
+    return "";
+  switch (row.event) {
+    case "session.waiting":
+      return meta.question ?? "";
+    case "session.answered": {
+      const answers = meta.answers;
+      return answers ? Object.values(answers).join(", ") : "";
+    }
+    case "permission.request":
+    case "permission.resolve": {
+      const tool = meta.tool ?? "";
+      const detail = meta.detail ?? "";
+      return detail ? `${tool}: ${detail}` : tool;
+    }
+    case "gh.pr.created": {
+      const title = meta.pr_title ?? "";
+      const url = meta.pr_url ?? "";
+      return title || url;
+    }
+    case "gh.pr.merged":
+      return meta.branch ?? "";
+    case "worktree.entered":
+      return meta.branch ?? "";
+    case "linear.issue.read":
+      return meta.issue_title ?? "";
+    case "notion.page.read":
+      return meta.page_title ?? "";
+    case "vercel.deploy":
+      return meta.project_name ?? "";
+    case "user.prompt":
+      return meta.prompt ?? "";
+    case "context.snapshot":
+      return meta.remaining_pct ? `${meta.remaining_pct}% remaining` : "";
+    case "session.recap":
+      return meta.recap ?? "";
+    default:
+      return "";
+  }
+}
+function enrich(row) {
+  const info = lookup(row.event);
+  return {
+    id: row.id,
+    sessionId: row.sessionId,
+    conversationId: row.conversationId,
+    event: row.event,
+    createdAt: row.createdAt,
+    meta: row.meta,
+    label: info.label,
+    category: info.category,
+    color: info.color,
+    detailColor: info.detailColor,
+    summary: extractSummary(row),
+    claudeId: extractClaudeId(row)
+  };
+}
+function enrichAll(rows) {
+  return rows.map(enrich);
+}
+var catalog, DEFAULT_INFO;
+var init_catalog = __esm(() => {
+  catalog = {
+    "session.started": { label: "started", category: "lifecycle", color: 34, detailColor: 245, skip: false },
+    "session.resumed": { label: "resumed", category: "lifecycle", color: 34, detailColor: 245, skip: false },
+    "session.end": { label: "ended", category: "lifecycle", color: 245, detailColor: 245, skip: false },
+    "claude.started": { label: "claude started", category: "lifecycle", color: 35, detailColor: 245, skip: false },
+    "claude.ended": { label: "claude ended", category: "lifecycle", color: 35, detailColor: 245, skip: false },
+    "claude.discarded": { label: "discarded", category: "lifecycle", color: 245, detailColor: 245, skip: false },
+    "session.waiting": { label: "waiting", category: "interaction", color: 33, detailColor: 245, skip: false },
+    "session.answered": { label: "answered", category: "interaction", color: 36, detailColor: 245, skip: false },
+    "permission.request": { label: "permission", category: "work", color: 214, detailColor: 245, skip: false },
+    "permission.resolve": { label: "allowed", category: "work", color: 214, detailColor: 245, skip: false },
+    "worktree.entered": { label: "worktree", category: "lifecycle", color: 35, detailColor: 245, skip: false },
+    "worktree.exited": { label: "worktree exited", category: "lifecycle", color: 35, detailColor: 245, skip: false },
+    "gh.pr.created": { label: "PR created", category: "integration", color: 32, detailColor: 32, skip: false },
+    "gh.pr.merged": { label: "PR merged", category: "integration", color: 35, detailColor: 35, skip: false },
+    "linear.issue.read": { label: "Linear issue", category: "integration", color: 33, detailColor: 33, skip: false },
+    "notion.page.read": { label: "Notion page", category: "integration", color: 245, detailColor: 245, skip: false },
+    "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.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 }
+  };
+  DEFAULT_INFO = {
+    label: "unknown",
+    category: "lifecycle",
+    color: 245,
+    detailColor: 245,
+    skip: false
+  };
+});
+
+// src/lib/compact.ts
+function repairQAPairs(events2) {
+  const result = [...events2];
+  for (let i = 0;i < result.length; i++) {
+    const ev = result[i];
+    if (ev.event !== "session.answered")
+      continue;
+    let blockIdx = -1;
+    for (let j = i - 1;j >= 0; j--) {
+      const candidate = result[j];
+      if (candidate.event === "session.waiting" && candidate.claudeId === ev.claudeId) {
+        blockIdx = j;
+        break;
+      }
+    }
+    if (blockIdx === -1)
+      continue;
+    if (blockIdx === i - 1)
+      continue;
+    result.splice(i, 1);
+    result.splice(blockIdx + 1, 0, ev);
+  }
+  return result;
+}
+function collapsePermissions(events2) {
+  const result = [];
+  let i = 0;
+  while (i < events2.length) {
+    const ev = events2[i];
+    if (ev.event !== "permission.request" && ev.event !== "permission.resolve") {
+      result.push(ev);
+      i++;
+      continue;
+    }
+    const batch = [];
+    while (i < events2.length) {
+      const current = events2[i];
+      if (current.event !== "permission.request" && current.event !== "permission.resolve")
+        break;
+      batch.push(current);
+      i++;
+    }
+    if (batch.length === 0)
+      continue;
+    const toolCounts = new Map;
+    for (const pev of batch) {
+      if (pev.event !== "permission.request")
+        continue;
+      const meta = pev.meta;
+      const tool = meta?.tool ?? "unknown";
+      toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + 1);
+    }
+    const sorted = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]);
+    const summary = batch.length === 1 ? formatSinglePermission(batch[0]) : sorted.map(([tool, count]) => `${count}\xD7 ${tool}`).join(", ");
+    const first = batch[0];
+    const last = batch[batch.length - 1];
+    const midMs = (new Date(first.createdAt).getTime() + new Date(last.createdAt).getTime()) / 2;
+    result.push({
+      ...first,
+      event: "tool.work",
+      label: "tool work",
+      category: "work",
+      summary,
+      createdAt: new Date(midMs).toISOString()
+    });
+  }
+  return result;
+}
+function formatSinglePermission(ev) {
+  const meta = ev.meta;
+  const tool = meta?.tool ?? "";
+  const detail = meta?.detail ?? "";
+  if (!detail)
+    return tool;
+  switch (tool) {
+    case "Bash":
+      return `ran \`${detail}\``;
+    case "Edit":
+    case "Write":
+      return `${tool.toLowerCase()} ${detail}`;
+    default:
+      return `${tool}: ${detail}`;
+  }
+}
+function deduplicate(events2) {
+  if (events2.length === 0)
+    return [];
+  const result = [events2[0]];
+  for (let i = 1;i < events2.length; i++) {
+    const current = events2[i];
+    const prev = result[result.length - 1];
+    if (current.event === prev.event && current.summary === prev.summary) {
+      result[result.length - 1] = current;
+    } else {
+      result.push(current);
+    }
+  }
+  return result;
+}
+function filterSkipped(events2) {
+  return events2.filter((ev) => !lookup(ev.event).skip);
+}
+function compact(events2) {
+  return deduplicate(collapsePermissions(repairQAPairs(filterSkipped(events2))));
+}
+var init_compact = __esm(() => {
+  init_catalog();
+});
+
+// src/cli/commands/log.ts
+var exports_log = {};
+function ansi(code, text2) {
+  return `\x1B[${code}m${text2}${RESET}`;
+}
+function ansi256(code, text2) {
+  return `\x1B[38;5;${code}m${text2}${RESET}`;
+}
+function showAllSessions() {
+  const rows = getAllSessions().sort((a, b) => new Date(b.session.updatedAt).getTime() - new Date(a.session.updatedAt).getTime());
+  if (rows.length === 0) {
+    console.log("No sessions.");
+    return;
+  }
+  const maxName = Math.max(...rows.map((r) => `${r.groupPath}/${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 dot = STATUS_DOTS2[row.session.status] ?? "?";
+    const stats = getSessionStats(row.session.id);
+    const eventCount = String(stats?.eventCount ?? 0).padEnd(6);
+    const ago = formatAgo(row.session.updatedAt);
+    console.log(`${dot} ${name.padEnd(maxName)}  ${row.session.status.padEnd(10)}  ${eventCount}  ${ago}`);
+  }
+}
+function segmentByConversation(events2) {
+  const segments = [];
+  let current = null;
+  for (const ev of events2) {
+    if (ev.event === "claude.started") {
+      current = { claudeId: ev.claudeId ?? "unknown", events: [ev] };
+      segments.push(current);
+    } else if (current) {
+      current.events.push(ev);
+    } else {
+      if (segments.length === 0) {
+        current = { claudeId: ev.claudeId ?? "unknown", events: [ev] };
+        segments.push(current);
+      } else {
+        segments[segments.length - 1].events.push(ev);
+      }
+    }
+  }
+  return segments;
+}
+function renderConnector(idx, total) {
+  if (total === 1)
+    return `${PIPE_COLOR}\u2500${RESET}`;
+  if (idx === 0)
+    return `${PIPE_COLOR}\u250C${RESET}`;
+  if (idx === total - 1)
+    return `${PIPE_COLOR}\u2514${RESET}`;
+  return `${PIPE_COLOR}\u251C${RESET}`;
+}
+function renderGap(prevTime, currTime) {
+  const gap = new Date(currTime).getTime() - new Date(prevTime).getTime();
+  if (gap < GAP_THRESHOLD_MS)
+    return null;
+  return `${PIPE_COLOR}\u2502${RESET} ${DIM}  \xB7\xB7\xB7 ${formatDuration(gap)} \xB7\xB7\xB7${RESET}`;
+}
+function renderEventLine(ev) {
+  const time = formatTime(ev.createdAt);
+  const label = ansi256(ev.color, ev.label);
+  const detail = ev.summary ? `${DIM}${truncate(ev.summary, 60)}${RESET}` : "";
+  return `${DIM}${time}${RESET} ${label}${detail ? ` ${detail}` : ""}`;
+}
+function renderQAPair(block, resume2) {
+  const lines = [];
+  const time = formatTime(block.createdAt);
+  const question = block.summary ? truncate(block.summary, 60) : "";
+  lines.push(`${DIM}${time}${RESET} ${ansi256(block.color, block.label)}${question ? ` ${DIM}${question}${RESET}` : ""}`);
+  if (resume2) {
+    const answer = resume2.summary ? truncate(resume2.summary, 60) : "";
+    lines.push(`${PIPE_COLOR}\u2502${RESET}   ${ansi256(resume2.color, "\u2514 " + resume2.label)}${answer ? ` ${DIM}${answer}${RESET}` : ""}`);
+  }
+  return lines;
+}
+function renderSegment(seg, segIdx, totalSegs) {
+  const lines = [];
+  if (totalSegs > 1) {
+    const header = `${BOLD}Conversation ${segIdx + 1}${RESET}`;
+    if (segIdx > 0)
+      lines.push("");
+    lines.push(header);
+  }
+  for (let i = 0;i < seg.events.length; i++) {
+    const ev = seg.events[i];
+    const connector = renderConnector(i, seg.events.length);
+    if (i > 0) {
+      const gap = renderGap(seg.events[i - 1].createdAt, ev.createdAt);
+      if (gap)
+        lines.push(gap);
+    }
+    if (ev.event === "session.waiting") {
+      const next = seg.events[i + 1];
+      const resume2 = next?.event === "session.answered" ? next : undefined;
+      const qaLines = renderQAPair(ev, resume2);
+      lines.push(`${connector} ${qaLines[0]}`);
+      for (let j = 1;j < qaLines.length; j++) {
+        lines.push(`  ${qaLines[j]}`);
+      }
+      if (resume2)
+        i++;
+      continue;
+    }
+    lines.push(`${connector} ${renderEventLine(ev)}`);
+  }
+  return lines;
+}
+function renderTimingFooter(sessionId) {
+  const stats = getSessionStats(sessionId);
+  const lines = [];
+  let claudeWorkS;
+  let userWaitS;
+  let activePctVal;
+  let durationS;
+  if (stats) {
+    claudeWorkS = stats.claudeWorkS;
+    userWaitS = stats.userWaitS;
+    activePctVal = stats.activePct;
+    durationS = stats.durationS;
+  } else {
+    const timing = computeTimingsLive(sessionId);
+    claudeWorkS = Math.round(timing.totalClaudeWorkMs / 1000);
+    userWaitS = Math.round(timing.totalUserWaitMs / 1000);
+    activePctVal = timing.activePct;
+    durationS = timing.durationS;
+  }
+  if (durationS === 0)
+    return lines;
+  lines.push("");
+  lines.push(`${DIM}Duration: ${formatDuration(durationS * 1000)} \xB7 Claude: ${formatDuration(claudeWorkS * 1000)} (${activePctVal}%) \xB7 Wait: ${formatDuration(userWaitS * 1000)} (${100 - activePctVal}%)${RESET}`);
+  return lines;
+}
+function showSessionLog(session, sessionName, isJson) {
+  const sessionId = session.id;
+  const rawEvents = getEventsBySession(sessionId);
+  const enriched = enrichAll(rawEvents);
+  const compacted = compact(enriched);
+  if (isJson) {
+    const stats = getSessionStats(sessionId);
+    const conversations2 = getConversationsBySession(sessionId);
+    console.log(JSON.stringify({
+      session: { ...session, name: sessionName },
+      stats,
+      conversations: conversations2,
+      events: compacted.map((e) => ({
+        event: e.event,
+        label: e.label,
+        category: e.category,
+        summary: e.summary,
+        meta: e.meta,
+        createdAt: e.createdAt,
+        claudeId: e.claudeId
+      }))
+    }, null, 2));
+    return;
+  }
+  const segments = segmentByConversation(compacted);
+  const allLines = [];
+  for (let i = 0;i < segments.length; i++) {
+    const segLines = renderSegment(segments[i], i, segments.length);
+    allLines.push(...segLines);
+  }
+  allLines.push(...renderTimingFooter(sessionId));
+  for (const line of allLines) {
+    console.log(line);
+  }
+}
+var DIM = "\x1B[2m", BOLD = "\x1B[1m", RESET = "\x1B[0m", PIPE_COLOR = "\x1B[38;5;238m", STATUS_DOTS2, GAP_THRESHOLD_MS = 5000;
+var init_log = __esm(() => {
+  init_router();
+  init_sessions();
+  init_events();
+  init_groups();
+  init_stats();
+  init_conversations();
+  init_catalog();
+  init_compact();
+  init_timing();
+  init_format();
+  STATUS_DOTS2 = {
+    active: ansi(32, "\u25CF"),
+    waiting: ansi(33, "\u25CF"),
+    paused: `${DIM}\u25CF${RESET}`,
+    archived: `${DIM}\u25CB${RESET}`
+  };
+  register("log", async (args) => {
+    const isJson = args.includes("--json");
+    const filteredArgs = args.filter((a) => !a.startsWith("--"));
+    const target = filteredArgs[0];
+    if (!target) {
+      showAllSessions();
+      return;
+    }
+    const { groupPath, slug } = parseSessionName(target);
+    const group = getGroupByPath(groupPath);
+    if (!group) {
+      console.error(`Group not found: ${groupPath}`);
+      process.exit(1);
+    }
+    const session = getSessionByGroupSlug(group.id, slug);
+    if (!session) {
+      console.error(`Session not found: ${target}`);
+      process.exit(1);
+    }
+    showSessionLog(session, `${groupPath}/${slug}`, isJson);
+  });
+});
+
+// src/cli/commands/stats.ts
+var exports_stats = {};
+function getMetrics(sessionId, name, status) {
+  const stats = getSessionStats(sessionId);
+  if (stats) {
+    return { name, status, ...stats };
+  }
+  const timing = computeTimingsLive(sessionId);
+  const allEvents = getEventsBySession(sessionId);
+  const conversations2 = new Set;
+  let interactionCount = 0;
+  let prCount = 0;
+  for (const ev of allEvents) {
+    if (ev.conversationId)
+      conversations2.add(ev.conversationId);
+    if (ev.event === "session.waiting" || ev.event === "session.answered")
+      interactionCount++;
+    if (ev.event === "gh.pr.created")
+      prCount++;
+  }
+  return {
+    name,
+    status,
+    eventCount: allEvents.length,
+    conversationCount: conversations2.size,
+    interactionCount,
+    prCount,
+    claudeWorkS: Math.round(timing.totalClaudeWorkMs / 1000),
+    userWaitS: Math.round(timing.totalUserWaitMs / 1000),
+    activePct: timing.activePct,
+    durationS: timing.durationS
+  };
+}
+function pct(n) {
+  return `${n}%`;
+}
+function dur(seconds) {
+  return seconds > 0 ? formatDuration(seconds * 1000) : "-";
+}
+function renderGlobal(metrics, isJson) {
+  const totals = metrics.reduce((acc, m) => ({
+    sessions: acc.sessions + 1,
+    active: acc.active + (ACTIVE_STATUSES.includes(m.status) ? 1 : 0),
+    durationS: acc.durationS + m.durationS,
+    claudeWorkS: acc.claudeWorkS + m.claudeWorkS,
+    userWaitS: acc.userWaitS + m.userWaitS,
+    conversations: acc.conversations + m.conversationCount,
+    prs: acc.prs + m.prCount,
+    interactions: acc.interactions + m.interactionCount
+  }), { sessions: 0, active: 0, durationS: 0, claudeWorkS: 0, userWaitS: 0, conversations: 0, prs: 0, interactions: 0 });
+  const totalTracked = totals.claudeWorkS + totals.userWaitS;
+  const globalActivePct = totalTracked > 0 ? Math.round(totals.claudeWorkS / totalTracked * 100) : 0;
+  if (isJson) {
+    console.log(JSON.stringify({ ...totals, activePct: globalActivePct }, null, 2));
+    return;
+  }
+  const dim = "\x1B[2m";
+  const bold = "\x1B[1m";
+  const reset = "\x1B[0m";
+  console.log(`${bold}Global Statistics${reset}
+`);
+  console.log(`  Sessions:      ${totals.sessions} (${totals.active} active)`);
+  console.log(`  Total time:    ${dur(totals.durationS)}`);
+  console.log(`  Claude work:   ${dur(totals.claudeWorkS)} ${dim}(${pct(globalActivePct)})${reset}`);
+  console.log(`  User wait:     ${dur(totals.userWaitS)} ${dim}(${pct(100 - globalActivePct)})${reset}`);
+  console.log(`  Conversations: ${totals.conversations}`);
+  console.log(`  PRs:           ${totals.prs}`);
+  console.log(`  Interactions:  ${totals.interactions}`);
+}
+function renderGroup(metrics, groupPath, isJson) {
+  if (isJson) {
+    console.log(JSON.stringify(metrics, null, 2));
+    return;
+  }
+  const dim = "\x1B[2m";
+  const bold = "\x1B[1m";
+  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(`${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) {
+    console.log(`${m.name.padEnd(maxName)}  ${dur(m.durationS).padEnd(8)}  ${dur(m.claudeWorkS).padEnd(8)}  ${dur(m.userWaitS).padEnd(8)}  ${pct(m.activePct).padEnd(5)}  ${String(m.conversationCount).padEnd(6)}  ${m.prCount}`);
+  }
+  const totals = sorted.reduce((acc, m) => ({
+    durationS: acc.durationS + m.durationS,
+    claudeWorkS: acc.claudeWorkS + m.claudeWorkS,
+    userWaitS: acc.userWaitS + m.userWaitS,
+    conversations: acc.conversations + m.conversationCount,
+    prs: acc.prs + m.prCount
+  }), { durationS: 0, claudeWorkS: 0, userWaitS: 0, conversations: 0, prs: 0 });
+  const totalTracked = totals.claudeWorkS + totals.userWaitS;
+  const totalPct = totalTracked > 0 ? Math.round(totals.claudeWorkS / totalTracked * 100) : 0;
+  console.log(`${dim}${"\u2500".repeat(maxName + 50)}${reset}`);
+  console.log(`${"TOTAL".padEnd(maxName)}  ${dur(totals.durationS).padEnd(8)}  ${dur(totals.claudeWorkS).padEnd(8)}  ${dur(totals.userWaitS).padEnd(8)}  ${pct(totalPct).padEnd(5)}  ${String(totals.conversations).padEnd(6)}  ${totals.prs}`);
+}
+function renderSession(m, isJson) {
+  if (isJson) {
+    console.log(JSON.stringify(m, null, 2));
+    return;
+  }
+  const dim = "\x1B[2m";
+  const bold = "\x1B[1m";
+  const reset = "\x1B[0m";
+  console.log(`${bold}${m.name}${reset} ${dim}(${m.status})${reset}
+`);
+  console.log(`  Duration:      ${dur(m.durationS)}`);
+  console.log(`  Claude work:   ${dur(m.claudeWorkS)} ${dim}(${pct(m.activePct)})${reset}`);
+  console.log(`  User wait:     ${dur(m.userWaitS)} ${dim}(${pct(100 - m.activePct)})${reset}`);
+  console.log(`  Events:        ${m.eventCount}`);
+  console.log(`  Conversations: ${m.conversationCount}`);
+  console.log(`  Interactions:  ${m.interactionCount}`);
+  console.log(`  PRs:           ${m.prCount}`);
+}
+var ACTIVE_STATUSES;
+var init_stats2 = __esm(() => {
+  init_router();
+  init_sessions();
+  init_stats();
+  init_groups();
+  init_events();
+  init_timing();
+  init_format();
+  ACTIVE_STATUSES = ["active", "waiting"];
+  register("stats", async (args) => {
+    const isJson = args.includes("--json");
+    const filteredArgs = args.filter((a) => !a.startsWith("--"));
+    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));
+      renderGlobal(metrics, isJson);
+      return;
+    }
+    if (target.endsWith("/")) {
+      const groupPath2 = target.replace(/\/+$/, "");
+      const group2 = getGroupByPath(groupPath2);
+      if (!group2) {
+        console.error(`Group not found: ${groupPath2}`);
+        process.exit(1);
+      }
+      const groupSessions = getSessionsByGroup(group2.id);
+      const metrics = groupSessions.map((s) => getMetrics(s.id, s.slug, s.status));
+      renderGroup(metrics, groupPath2, isJson);
+      return;
+    }
+    const { groupPath, slug } = parseSessionName(target);
+    const group = getGroupByPath(groupPath);
+    if (!group) {
+      console.error(`Group not found: ${groupPath}`);
+      process.exit(1);
+    }
+    const session = getSessionByGroupSlug(group.id, slug);
+    if (!session) {
+      console.error(`Session not found: ${target}`);
+      process.exit(1);
+    }
+    const m = getMetrics(session.id, `${groupPath}/${slug}`, session.status);
+    renderSession(m, isJson);
+  });
+});
+
+// src/cli/commands/backfill-stats.ts
+var exports_backfill_stats = {};
+var init_backfill_stats = __esm(() => {
+  init_router();
+  init_sessions();
+  init_timing();
+  register("backfill-stats", async (args) => {
+    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) {
+      computeAndPersist(session.id);
+      console.log(`  \u2713 ${groupPath}/${session.slug}`);
+    }
+    console.log("Done.");
+  });
+});
+
+// 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}`);
+    process.exit(1);
+  }
+  const session = getSessionByGroupSlug(group.id, slug);
+  if (!session) {
+    console.error(`Session not found: ${name}`);
+    process.exit(1);
+  }
+  return { session, groupPath };
+}
+var ACTIVE_STATUSES2;
+var init_archive = __esm(() => {
+  init_router();
+  init_sessions();
+  init_groups();
+  ACTIVE_STATUSES2 = ["active", "waiting"];
+  register("archive", async (args) => {
+    const isUndo = args.includes("--undo");
+    const isAllPaused = args.includes("--all-paused");
+    const filteredArgs = args.filter((a) => !a.startsWith("--"));
+    const sessionName = filteredArgs[0];
+    if (isAllPaused) {
+      const rows = getAllSessions({ excludeArchived: true });
+      const paused = rows.filter((r) => r.session.status === "paused");
+      if (paused.length === 0) {
+        console.log("No paused sessions to archive.");
+        return;
+      }
+      let archived = 0;
+      for (const row of paused) {
+        updateSessionStatus(row.session.id, "archived");
+        console.log(`  archived ${row.groupPath}/${row.session.slug}`);
+        archived++;
+      }
+      console.log(`
+Archived ${archived} session${archived === 1 ? "" : "s"}.`);
+      return;
+    }
+    if (!sessionName) {
+      console.error("Usage: bertrand archive <session>");
+      console.error("       bertrand archive --undo <session>");
+      console.error("       bertrand archive --all-paused");
+      process.exit(1);
+    }
+    const { session, groupPath } = resolveSession(sessionName);
+    const fullName = `${groupPath}/${session.slug}`;
+    if (isUndo) {
+      if (session.status !== "archived") {
+        console.error(`${fullName} is not archived (status: ${session.status})`);
+        process.exit(1);
+      }
+      updateSessionStatus(session.id, "paused");
+      console.log(`Unarchived ${fullName}`);
+      return;
+    }
+    if (ACTIVE_STATUSES2.includes(session.status)) {
+      console.error(`Cannot archive active session ${fullName} (status: ${session.status})`);
+      process.exit(1);
+    }
+    if (session.status === "archived") {
+      console.error(`${fullName} is already archived`);
+      process.exit(1);
+    }
+    updateSessionStatus(session.id, "archived");
+    console.log(`Archived ${fullName}`);
+  });
+});
+
+// src/index.ts
+init_router();
+var command = process.argv[2];
+var hotPath = {
+  update: () => Promise.resolve().then(() => (init_update(), exports_update)),
+  snapshot: () => Promise.resolve().then(() => (init_snapshot(), exports_snapshot)),
+  "assistant-message": () => Promise.resolve().then(() => (init_assistant_message(), exports_assistant_message)),
+  "recap-thinking": () => Promise.resolve().then(() => (init_recap_thinking(), exports_recap_thinking)),
+  badge: () => Promise.resolve().then(() => (init_badge(), exports_badge)),
+  notify: () => Promise.resolve().then(() => (init_notify(), exports_notify)),
+  serve: () => Promise.resolve().then(() => (init_serve(), exports_serve))
+};
+if (command && command in hotPath) {
+  await hotPath[command]();
+} else {
+  await Promise.all([
+    Promise.resolve().then(() => (init_launch(), exports_launch)),
+    Promise.resolve().then(() => (init_init(), exports_init)),
+    Promise.resolve().then(() => (init_list(), exports_list)),
+    Promise.resolve().then(() => (init_log(), exports_log)),
+    Promise.resolve().then(() => (init_stats2(), exports_stats)),
+    Promise.resolve().then(() => (init_backfill_stats(), exports_backfill_stats)),
+    Promise.resolve().then(() => (init_archive(), exports_archive)),
+    Promise.resolve().then(() => (init_update(), exports_update)),
+    Promise.resolve().then(() => (init_snapshot(), exports_snapshot)),
+    Promise.resolve().then(() => (init_assistant_message(), exports_assistant_message)),
+    Promise.resolve().then(() => (init_recap_thinking(), exports_recap_thinking)),
+    Promise.resolve().then(() => (init_serve(), exports_serve)),
+    Promise.resolve().then(() => (init_badge(), exports_badge)),
+    Promise.resolve().then(() => (init_notify(), exports_notify))
+  ]);
+}
+await route(process.argv);
+process.exit(0);