@owloops/browserbird 1.5.9 → 1.6.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { $ as touchSession, A as SYSTEM_CRON_PREFIX, B as listCronJobs, C as failStaleJobs, D as listJobs, E as hasPendingCronJob, F as deleteOldCronRuns, G as createSession, H as setCronJobEnabled, I as ensureSystemCronJob, J as getSession, K as deleteOldSessions, L as getCronJob, M as createCronJob, N as createCronRun, O as retryAllFailedJobs, P as deleteCronJob, Q as listSessions, R as getEnabledCronJobs, S as failJob, T as getJobStatus, U as updateCronJob, V as listFlights, W as updateCronJobStatus, X as getSessionMessages, Y as getSessionCount, Z as getSessionTokenStats, _ as clearJobs, a as getSetting, at as optimizeDatabase, b as deleteJob, c as getUserCount, d as getRecentLogs, et as updateSessionProviderId, f as insertLog, g as claimNextJob, h as logMessage, i as createUser, it as openDatabase, j as completeCronRun, k as retryJob, l as setSetting, m as getMessageStats, n as resolveDbPath, nt as closeDatabase, o as getUserByEmail, ot as resolveByUid, p as deleteOldMessages, q as findSession, r as resolveDbPathFromArgv, rt as getDb, s as getUserById, st as logger, tt as shortUid, u as deleteOldLogs, v as completeJob, w as getJobStats, x as deleteOldJobs, y as createJob, z as getFlightStats } from "./db-BNF1vZIm.mjs";
 import { createRequire } from "node:module";
 import { parseArgs, styleText } from "node:util";
-import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import { createHmac, randomBytes, scrypt, timingSafeEqual } from "node:crypto";
 import { connect } from "node:net";
 import { execFileSync, spawn } from "node:child_process";
@@ -21,6 +21,76 @@ const COMMANDS = {
 	DOCTOR: "doctor"
 };
 
+//#endregion
+//#region src/core/logger.ts
+/**
+* @fileoverview Structured logger. Respects NO_COLOR.
+*
+* Stream routing by mode:
+*   - CLI mode (default): all logs to stderr, keeping stdout clean for data output.
+*   - Daemon mode: errors/warnings to stderr, everything else to stdout.
+*     Cloud platforms (Railway, Fly, etc.) treat stderr lines as errors, so this
+*     prevents info lines from showing up red.
+*
+* Call `logger.setMode('daemon')` once at startup to switch.
+*/
+function shouldUseColor$1() {
+	if (process.env["NO_COLOR"] !== void 0) return false;
+	if (process.env["TERM"] === "dumb") return false;
+	if (process.argv.includes("--no-color")) return false;
+	return process.stdout.isTTY === true || process.stderr.isTTY === true;
+}
+const useColor$1 = shouldUseColor$1();
+function style(format, text) {
+	if (!useColor$1) return text;
+	return styleText(format, text);
+}
+const LOG_LEVELS = {
+	ERROR: 0,
+	WARN: 1,
+	INFO: 2,
+	DEBUG: 3
+};
+let currentLevel = LOG_LEVELS.INFO;
+let daemonMode = false;
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+function out(prefix, message) {
+	(daemonMode ? process.stdout : process.stderr).write(`${style("dim", timestamp())} ${prefix} ${message}\n`);
+}
+function err(prefix, message) {
+	process.stderr.write(`${style("dim", timestamp())} ${prefix} ${message}\n`);
+}
+const logger = {
+	error(message) {
+		if (currentLevel >= LOG_LEVELS.ERROR) err(style("red", "[error]"), message);
+	},
+	warn(message) {
+		if (currentLevel >= LOG_LEVELS.WARN) err(style("yellow", "[warn]"), message);
+	},
+	info(message) {
+		if (currentLevel >= LOG_LEVELS.INFO) out(style("blue", "[info]"), message);
+	},
+	debug(message) {
+		if (currentLevel >= LOG_LEVELS.DEBUG) out(style("dim", "[debug]"), message);
+	},
+	success(message) {
+		if (currentLevel >= LOG_LEVELS.INFO) out(style("green", "[ok]"), message);
+	},
+	setLevel(level) {
+		currentLevel = {
+			error: LOG_LEVELS.ERROR,
+			warn: LOG_LEVELS.WARN,
+			info: LOG_LEVELS.INFO,
+			debug: LOG_LEVELS.DEBUG
+		}[level] ?? LOG_LEVELS.INFO;
+	},
+	setMode(mode) {
+		daemonMode = mode === "daemon";
+	}
+};
+
 //#endregion
 //#region src/core/utils.ts
 /** @fileoverview Shared utilities: formatting, time ranges, and CLI table output. */
@@ -122,8 +192,8 @@ function unknownSubcommand(subcommand, command, validCommands) {
 /** @fileoverview ASCII banner displayed on daemon startup and in help text. */
 const pkg = createRequire(import.meta.url)("../package.json");
 const buildInfo = [];
-buildInfo.push(`commit: ${"079abaeb36f4cadf0afba256b58885e1e8280174".substring(0, 7)}`);
-buildInfo.push(`built: 2026-03-18T11:14:06+04:00`);
+buildInfo.push(`commit: ${"8468e2519ab927c9f810bc3af7d127829a93c83e".substring(0, 7)}`);
+buildInfo.push(`built: 2026-03-19T13:57:16+04:00`);
 const buildString = buildInfo.length > 0 ? ` (${buildInfo.join(", ")})` : "";
 const VERSION = `browserbird ${pkg.version}${buildString}`;
 const BIRD = [
@@ -346,6 +416,329 @@ function loadDotEnv(envPath) {
 	}
 }
 
+//#endregion
+//#region src/db/core.ts
+/** @fileoverview SQLite database lifecycle, migrations, and query utilities. */
+const DEFAULT_PER_PAGE = 15;
+const MAX_PER_PAGE = 100;
+/**
+* Parses a sort string into an SQL ORDER BY clause.
+* Each token is a column name optionally prefixed with `-` for DESC.
+* Only columns present in `allowedColumns` are included.
+*/
+function parseSort(raw, allowedColumns, fallback) {
+	if (!raw) return fallback;
+	const parts = [];
+	for (const token of raw.split(",")) {
+		const trimmed = token.trim();
+		if (!trimmed) continue;
+		const desc = trimmed.startsWith("-");
+		const col = desc ? trimmed.slice(1) : trimmed;
+		if (allowedColumns.has(col)) parts.push(`${col} ${desc ? "DESC" : "ASC"}`);
+	}
+	return parts.length > 0 ? parts.join(", ") : fallback;
+}
+/**
+* Builds a parenthesized OR clause for LIKE-based search across columns.
+* Returns empty sql/params when the search term is empty.
+*/
+function buildSearchClause(term, columns) {
+	if (!term || columns.length === 0) return {
+		sql: "",
+		params: []
+	};
+	const like = `%${term}%`;
+	return {
+		sql: `(${columns.map((c) => `${c} LIKE ?`).join(" OR ")})`,
+		params: columns.map(() => like)
+	};
+}
+function paginate(table, page, perPage, whereOrOptions, params, orderBy) {
+	let where;
+	let allParams;
+	let resolvedOrderBy;
+	if (typeof whereOrOptions === "object" && whereOrOptions !== null) {
+		const opts = whereOrOptions;
+		const conditions = [];
+		allParams = [...opts.params ?? []];
+		if (opts.where) conditions.push(opts.where);
+		if (opts.search && opts.searchColumns && opts.searchColumns.length > 0) {
+			const sc = buildSearchClause(opts.search, opts.searchColumns);
+			if (sc.sql) {
+				conditions.push(sc.sql);
+				allParams.push(...sc.params);
+			}
+		}
+		where = conditions.join(" AND ");
+		resolvedOrderBy = parseSort(opts.sort, opts.allowedSortColumns ?? /* @__PURE__ */ new Set(), opts.defaultSort ?? "created_at DESC");
+	} else {
+		where = whereOrOptions ?? "";
+		allParams = params ?? [];
+		resolvedOrderBy = orderBy ?? "created_at DESC";
+	}
+	const pp = Math.min(Math.max(perPage, 1), MAX_PER_PAGE);
+	const p = Math.max(page, 1);
+	const offset = (p - 1) * pp;
+	const countSql = `SELECT COUNT(*) as count FROM ${table}${where ? ` WHERE ${where}` : ""}`;
+	const totalItems = getDb().prepare(countSql).get(...allParams).count;
+	const totalPages = Math.max(Math.ceil(totalItems / pp), 1);
+	const dataSql = `SELECT * FROM ${table}${where ? ` WHERE ${where}` : ""} ORDER BY ${resolvedOrderBy} LIMIT ? OFFSET ?`;
+	return {
+		items: getDb().prepare(dataSql).all(...allParams, pp, offset),
+		page: p,
+		perPage: pp,
+		totalItems,
+		totalPages
+	};
+}
+/**
+* Versioned migration registry. Each entry runs once, in order.
+* PRAGMA user_version tracks which migrations have been applied.
+* All DDL uses IF NOT EXISTS for idempotency.
+*/
+const MIGRATIONS = [
+	{
+		name: "initial schema",
+		up(d) {
+			d.exec(`
+        CREATE TABLE IF NOT EXISTS users (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          email TEXT UNIQUE NOT NULL COLLATE NOCASE,
+          password_hash TEXT NOT NULL,
+          token_key TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS settings (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS sessions (
+          uid TEXT PRIMARY KEY,
+          channel_id TEXT NOT NULL,
+          thread_id TEXT,
+          agent_id TEXT NOT NULL DEFAULT 'default',
+          provider_session_id TEXT NOT NULL,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          last_active TEXT NOT NULL DEFAULT (datetime('now')),
+          message_count INTEGER NOT NULL DEFAULT 0,
+          UNIQUE(channel_id, thread_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS cron_jobs (
+          uid TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          agent_id TEXT NOT NULL DEFAULT 'default',
+          schedule TEXT NOT NULL,
+          prompt TEXT NOT NULL,
+          target_channel_id TEXT,
+          active_hours_start TEXT,
+          active_hours_end TEXT,
+          enabled INTEGER NOT NULL DEFAULT 1,
+          failure_count INTEGER NOT NULL DEFAULT 0,
+          last_run TEXT,
+          last_status TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS cron_runs (
+          uid TEXT PRIMARY KEY,
+          job_uid TEXT NOT NULL REFERENCES cron_jobs(uid),
+          started_at TEXT NOT NULL DEFAULT (datetime('now')),
+          finished_at TEXT,
+          status TEXT NOT NULL DEFAULT 'running',
+          result TEXT,
+          error TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+          id INTEGER PRIMARY KEY,
+          channel_id TEXT NOT NULL,
+          thread_id TEXT,
+          user_id TEXT NOT NULL,
+          direction TEXT NOT NULL CHECK(direction IN ('in', 'out')),
+          content TEXT,
+          tokens_in INTEGER,
+          tokens_out INTEGER,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS jobs (
+          id INTEGER PRIMARY KEY,
+          name TEXT NOT NULL,
+          payload TEXT,
+          status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'running', 'completed', 'failed')),
+          priority TEXT NOT NULL DEFAULT 'normal' CHECK(priority IN ('high', 'normal', 'low')),
+          attempts INTEGER NOT NULL DEFAULT 0,
+          max_attempts INTEGER NOT NULL DEFAULT 1,
+          timeout INTEGER NOT NULL DEFAULT 1800,
+          cron_job_uid TEXT REFERENCES cron_jobs(uid),
+          run_at TEXT,
+          started_at TEXT,
+          completed_at TEXT,
+          result TEXT,
+          error TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS logs (
+          id INTEGER PRIMARY KEY,
+          level TEXT NOT NULL DEFAULT 'info' CHECK(level IN ('debug', 'info', 'warn', 'error')),
+          source TEXT NOT NULL,
+          message TEXT NOT NULL,
+          channel_id TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_sessions_channel_thread
+          ON sessions(channel_id, thread_id);
+        CREATE INDEX IF NOT EXISTS idx_sessions_last_active
+          ON sessions(last_active);
+        CREATE INDEX IF NOT EXISTS idx_messages_channel_thread
+          ON messages(channel_id, thread_id);
+        CREATE INDEX IF NOT EXISTS idx_messages_created_at
+          ON messages(created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_cron_runs_job_uid
+          ON cron_runs(job_uid, started_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled
+          ON cron_jobs(enabled);
+        CREATE INDEX IF NOT EXISTS idx_jobs_poll
+          ON jobs(status, priority, run_at, created_at);
+        CREATE INDEX IF NOT EXISTS idx_jobs_cron_job_uid
+          ON jobs(cron_job_uid);
+        CREATE INDEX IF NOT EXISTS idx_jobs_stale
+          ON jobs(status, started_at);
+        CREATE INDEX IF NOT EXISTS idx_logs_created_at
+          ON logs(created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_logs_level_source
+          ON logs(level, source, created_at DESC);
+      `);
+		}
+	},
+	{
+		name: "browser lock",
+		up(d) {
+			d.exec(`
+        CREATE TABLE IF NOT EXISTS browser_lock (
+          id INTEGER PRIMARY KEY CHECK(id = 1),
+          holder TEXT NOT NULL,
+          acquired_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+      `);
+		}
+	},
+	{
+		name: "feedback",
+		up(d) {
+			d.exec(`
+        CREATE TABLE IF NOT EXISTS feedback (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          channel_id TEXT NOT NULL,
+          thread_id TEXT,
+          message_ts TEXT,
+          user_id TEXT NOT NULL,
+          value TEXT NOT NULL CHECK(value IN ('good', 'bad')),
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          UNIQUE(channel_id, message_ts, user_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_feedback_channel_thread
+          ON feedback(channel_id, thread_id);
+      `);
+		}
+	}
+];
+let db = null;
+function getSchemaVersion(d) {
+	return d.prepare("PRAGMA user_version").get().user_version;
+}
+function setSchemaVersion(d, version) {
+	d.exec(`PRAGMA user_version = ${version}`);
+}
+/**
+* Runs pending migrations inside a transaction.
+* Safe to call on every startup; already-applied migrations are skipped.
+*/
+function migrate(d) {
+	const current = getSchemaVersion(d);
+	const target = MIGRATIONS.length;
+	if (current >= target) return;
+	for (let i = current; i < target; i++) {
+		const migration = MIGRATIONS[i];
+		logger.info(`migration ${i + 1}/${target}: ${migration.name}`);
+		d.exec("BEGIN");
+		try {
+			migration.up(d);
+			setSchemaVersion(d, i + 1);
+			d.exec("COMMIT");
+		} catch (err) {
+			d.exec("ROLLBACK");
+			throw new Error(`migration "${migration.name}" failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+		}
+	}
+}
+/**
+* Opens (or creates) the SQLite database at the given path.
+* Configures WAL mode, runs pending migrations.
+*/
+function openDatabase(dbPath) {
+	mkdirSync(dirname(dbPath), { recursive: true });
+	db = new DatabaseSync(dbPath);
+	db.exec("PRAGMA journal_mode = WAL");
+	db.exec("PRAGMA synchronous = NORMAL");
+	db.exec("PRAGMA foreign_keys = ON");
+	db.exec("PRAGMA busy_timeout = 5000");
+	migrate(db);
+	logger.debug(`database opened at ${dbPath}`);
+}
+function closeDatabase() {
+	if (db) {
+		db.close();
+		db = null;
+		logger.debug("database closed");
+	}
+}
+function getDb() {
+	if (!db) throw new Error("Database not initialized. Call openDatabase() first.");
+	return db;
+}
+/** Runs WAL checkpoint and query planner optimization. Safe to call periodically. */
+function optimizeDatabase() {
+	const d = getDb();
+	d.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+	d.exec("PRAGMA optimize");
+}
+/**
+* Resolves a row by UID or UID prefix, like git's short SHA resolution.
+* Exact match first (fast path), then prefix scan via LIKE.
+*/
+function resolveByUid(table, uidPrefix) {
+	const input = uidPrefix.toLowerCase();
+	const d = getDb();
+	const exact = d.prepare(`SELECT * FROM ${table} WHERE uid = ?`).get(input);
+	if (exact) return { row: exact };
+	const rows = d.prepare(`SELECT * FROM ${table} WHERE uid LIKE ? LIMIT 2`).all(`${input}%`);
+	if (rows.length === 0) return void 0;
+	if (rows.length > 1) return {
+		ambiguous: true,
+		count: d.prepare(`SELECT COUNT(*) as count FROM ${table} WHERE uid LIKE ?`).get(`${input}%`).count
+	};
+	return { row: rows[0] };
+}
+/** Wraps a function in BEGIN/COMMIT with automatic ROLLBACK on error. */
+function transaction(fn) {
+	const d = getDb();
+	d.exec("BEGIN IMMEDIATE");
+	try {
+		const result = fn();
+		d.exec("COMMIT");
+		return result;
+	} catch (err) {
+		d.exec("ROLLBACK");
+		throw err;
+	}
+}
+
 //#endregion
 //#region src/browser/lock.ts
 /** @fileoverview SQLite-based browser lock for persistent browser mode. */
@@ -390,6 +783,586 @@ function clearBrowserLock() {
 	getDb().prepare("DELETE FROM browser_lock WHERE id = 1").run();
 }
 
+//#endregion
+//#region src/core/uid.ts
+/** @fileoverview Prefixed short ID generation (PocketBase/Motebase pattern). */
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+const UID_PREFIX = {
+	bird: "br_",
+	flight: "fl_",
+	session: "ss_"
+};
+function generateUid(prefix) {
+	const bytes = randomBytes(15);
+	let id = prefix;
+	for (let i = 0; i < 15; i++) id += ALPHABET[bytes[i] % 36];
+	return id;
+}
+function shortUid(uid) {
+	const i = uid.indexOf("_");
+	if (i === -1) return uid.slice(0, 10);
+	return uid.slice(0, i + 1 + 7);
+}
+
+//#endregion
+//#region src/db/sessions.ts
+function findSession(channelId, threadId) {
+	return getDb().prepare("SELECT * FROM sessions WHERE channel_id = ? AND thread_id IS ?").get(channelId, threadId);
+}
+function createSession(channelId, threadId, agentId, providerSessionId) {
+	const uid = generateUid(UID_PREFIX.session);
+	return getDb().prepare(`INSERT INTO sessions (uid, channel_id, thread_id, agent_id, provider_session_id)
+     VALUES (?, ?, ?, ?, ?)
+     RETURNING *`).get(uid, channelId, threadId, agentId, providerSessionId);
+}
+function touchSession(uid, messageCountDelta = 1) {
+	getDb().prepare(`UPDATE sessions SET last_active = datetime('now'), message_count = message_count + ? WHERE uid = ?`).run(messageCountDelta, uid);
+}
+const SESSION_SORT_COLUMNS = new Set([
+	"uid",
+	"channel_id",
+	"agent_id",
+	"message_count",
+	"last_active",
+	"created_at"
+]);
+const SESSION_SEARCH_COLUMNS = [
+	"channel_id",
+	"thread_id",
+	"agent_id"
+];
+function listSessions(page = 1, perPage = DEFAULT_PER_PAGE, sort, search) {
+	return paginate("sessions", page, perPage, {
+		defaultSort: "last_active DESC",
+		sort,
+		search,
+		allowedSortColumns: SESSION_SORT_COLUMNS,
+		searchColumns: SESSION_SEARCH_COLUMNS
+	});
+}
+function getSession(uid) {
+	return getDb().prepare("SELECT * FROM sessions WHERE uid = ?").get(uid);
+}
+const MESSAGE_SORT_COLUMNS = new Set([
+	"id",
+	"created_at",
+	"direction",
+	"user_id"
+]);
+const MESSAGE_SEARCH_COLUMNS = ["content", "user_id"];
+function getSessionMessages(channelId, threadId, page = 1, perPage = DEFAULT_PER_PAGE, sort, search) {
+	const pp = Math.min(Math.max(perPage, 1), MAX_PER_PAGE);
+	const p = Math.max(page, 1);
+	const offset = (p - 1) * pp;
+	const conditions = ["channel_id = ? AND thread_id IS ?"];
+	const allParams = [channelId, threadId];
+	if (search) {
+		const sc = buildSearchClause(search, MESSAGE_SEARCH_COLUMNS);
+		if (sc.sql) {
+			conditions.push(sc.sql);
+			allParams.push(...sc.params);
+		}
+	}
+	const where = conditions.join(" AND ");
+	const orderBy = parseSort(sort, MESSAGE_SORT_COLUMNS, "created_at ASC, id ASC");
+	const totalItems = getDb().prepare(`SELECT COUNT(*) as count FROM messages WHERE ${where}`).get(...allParams).count;
+	const totalPages = Math.max(Math.ceil(totalItems / pp), 1);
+	return {
+		items: getDb().prepare(`SELECT * FROM messages
+       WHERE ${where}
+       ORDER BY ${orderBy}
+       LIMIT ? OFFSET ?`).all(...allParams, pp, offset),
+		page: p,
+		perPage: pp,
+		totalItems,
+		totalPages
+	};
+}
+function getSessionTokenStats(channelId, threadId) {
+	return getDb().prepare(`SELECT COALESCE(SUM(tokens_in), 0) as totalTokensIn,
+              COALESCE(SUM(tokens_out), 0) as totalTokensOut
+       FROM messages
+       WHERE channel_id = ? AND thread_id IS ?`).get(channelId, threadId);
+}
+function getSessionCount() {
+	return getDb().prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+}
+function deleteOldSessions(retentionDays) {
+	const result = getDb().prepare(`DELETE FROM sessions WHERE last_active < datetime('now', ? || ' days')`).run(`-${retentionDays}`);
+	return Number(result.changes);
+}
+function updateSessionProviderId(uid, providerSessionId) {
+	getDb().prepare("UPDATE sessions SET provider_session_id = ? WHERE uid = ?").run(providerSessionId, uid);
+}
+
+//#endregion
+//#region src/db/birds.ts
+const SYSTEM_CRON_PREFIX = "__bb_";
+const CRON_SORT_COLUMNS = new Set([
+	"uid",
+	"name",
+	"schedule",
+	"agent_id",
+	"enabled",
+	"last_run",
+	"created_at"
+]);
+const CRON_SEARCH_COLUMNS = [
+	"uid",
+	"name",
+	"prompt",
+	"schedule"
+];
+function listCronJobs(page = 1, perPage = DEFAULT_PER_PAGE, includeSystem = false, sort, search) {
+	return paginate("cron_jobs", page, perPage, {
+		where: includeSystem ? "" : `name NOT LIKE '${SYSTEM_CRON_PREFIX}%'`,
+		defaultSort: "created_at ASC",
+		sort,
+		search,
+		allowedSortColumns: CRON_SORT_COLUMNS,
+		searchColumns: CRON_SEARCH_COLUMNS
+	});
+}
+function getEnabledCronJobs() {
+	return getDb().prepare("SELECT * FROM cron_jobs WHERE enabled = 1 ORDER BY created_at").all();
+}
+function createCronJob(name, schedule, prompt, targetChannelId, agentId, activeHoursStart, activeHoursEnd) {
+	const uid = generateUid(UID_PREFIX.bird);
+	return getDb().prepare(`INSERT INTO cron_jobs (uid, name, schedule, prompt, target_channel_id, agent_id, active_hours_start, active_hours_end)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     RETURNING *`).get(uid, name, schedule, prompt, targetChannelId ?? null, agentId ?? "default", activeHoursStart ?? null, activeHoursEnd ?? null);
+}
+function updateCronJobStatus(jobUid, status, failureCount) {
+	getDb().prepare(`UPDATE cron_jobs SET last_run = datetime('now'), last_status = ?, failure_count = ? WHERE uid = ?`).run(status, failureCount, jobUid);
+}
+function getCronJob(jobUid) {
+	return getDb().prepare("SELECT * FROM cron_jobs WHERE uid = ?").get(jobUid);
+}
+function setCronJobEnabled(jobUid, enabled) {
+	const result = getDb().prepare("UPDATE cron_jobs SET enabled = ? WHERE uid = ?").run(enabled ? 1 : 0, jobUid);
+	return Number(result.changes) > 0;
+}
+function updateCronJob(jobUid, fields) {
+	const sets = [];
+	const params = [];
+	if (fields.name !== void 0) {
+		sets.push("name = ?");
+		params.push(fields.name);
+	}
+	if (fields.schedule !== void 0) {
+		sets.push("schedule = ?");
+		params.push(fields.schedule);
+	}
+	if (fields.prompt !== void 0) {
+		sets.push("prompt = ?");
+		params.push(fields.prompt);
+	}
+	if (fields.targetChannelId !== void 0) {
+		sets.push("target_channel_id = ?");
+		params.push(fields.targetChannelId);
+	}
+	if (fields.agentId !== void 0) {
+		sets.push("agent_id = ?");
+		params.push(fields.agentId);
+	}
+	if (fields.activeHoursStart !== void 0) {
+		sets.push("active_hours_start = ?");
+		params.push(fields.activeHoursStart);
+	}
+	if (fields.activeHoursEnd !== void 0) {
+		sets.push("active_hours_end = ?");
+		params.push(fields.activeHoursEnd);
+	}
+	if (sets.length === 0) return getCronJob(jobUid);
+	params.push(jobUid);
+	return getDb().prepare(`UPDATE cron_jobs SET ${sets.join(", ")} WHERE uid = ? RETURNING *`).get(...params);
+}
+function deleteCronJob(jobUid) {
+	const d = getDb();
+	d.exec("BEGIN");
+	try {
+		d.prepare("DELETE FROM cron_runs WHERE job_uid = ?").run(jobUid);
+		d.prepare("UPDATE jobs SET cron_job_uid = NULL WHERE cron_job_uid = ?").run(jobUid);
+		const result = d.prepare("DELETE FROM cron_jobs WHERE uid = ?").run(jobUid);
+		d.exec("COMMIT");
+		return Number(result.changes) > 0;
+	} catch (err) {
+		d.exec("ROLLBACK");
+		throw err;
+	}
+}
+const FLIGHT_SORT_COLUMNS = new Set([
+	"uid",
+	"started_at",
+	"finished_at",
+	"status",
+	"bird_name"
+]);
+const FLIGHT_SORT_MAP = { bird_name: "j.name" };
+const FLIGHT_SEARCH_COLUMNS = [
+	"r.uid",
+	"r.job_uid",
+	"j.uid",
+	"j.name",
+	"r.error",
+	"r.result"
+];
+function listFlights(page = 1, perPage = DEFAULT_PER_PAGE, filters = {}, sort, search) {
+	const pp = Math.min(Math.max(perPage, 1), MAX_PER_PAGE);
+	const p = Math.max(page, 1);
+	const offset = (p - 1) * pp;
+	const conditions = [];
+	const params = [];
+	if (!filters.system) conditions.push(`j.name NOT LIKE '${SYSTEM_CRON_PREFIX}%'`);
+	if (filters.birdUid != null) {
+		conditions.push("r.job_uid = ?");
+		params.push(filters.birdUid);
+	}
+	if (filters.status) {
+		conditions.push("r.status = ?");
+		params.push(filters.status);
+	}
+	if (search) {
+		const sc = buildSearchClause(search, FLIGHT_SEARCH_COLUMNS);
+		if (sc.sql) {
+			conditions.push(sc.sql);
+			params.push(...sc.params);
+		}
+	}
+	const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+	let orderBy = parseSort(sort, FLIGHT_SORT_COLUMNS, "r.started_at DESC");
+	for (const [key, qualified] of Object.entries(FLIGHT_SORT_MAP)) orderBy = orderBy.replaceAll(key, qualified);
+	orderBy = orderBy.replace(/(?<![a-z.])\b(uid|started_at|finished_at|status)\b/g, "r.$1");
+	const totalItems = getDb().prepare(`SELECT COUNT(*) as count FROM cron_runs r JOIN cron_jobs j ON j.uid = r.job_uid ${where}`).get(...params).count;
+	const totalPages = Math.max(Math.ceil(totalItems / pp), 1);
+	return {
+		items: getDb().prepare(`SELECT r.uid, r.job_uid, j.uid as bird_uid, j.name as bird_name,
+              r.started_at, r.finished_at, r.status, r.result, r.error
+       FROM cron_runs r
+       JOIN cron_jobs j ON j.uid = r.job_uid
+       ${where}
+       ORDER BY ${orderBy}
+       LIMIT ? OFFSET ?`).all(...params, pp, offset),
+		page: p,
+		perPage: pp,
+		totalItems,
+		totalPages
+	};
+}
+function createCronRun(jobUid) {
+	const uid = generateUid(UID_PREFIX.flight);
+	return getDb().prepare("INSERT INTO cron_runs (uid, job_uid) VALUES (?, ?) RETURNING *").get(uid, jobUid);
+}
+function completeCronRun(runUid, status, result, error) {
+	getDb().prepare(`UPDATE cron_runs SET finished_at = datetime('now'), status = ?, result = ?, error = ? WHERE uid = ?`).run(status, result ?? null, error ?? null, runUid);
+}
+function getFlightStats() {
+	const rows = getDb().prepare(`SELECT r.status, COUNT(*) as count
+       FROM cron_runs r
+       JOIN cron_jobs j ON j.uid = r.job_uid
+       WHERE j.name NOT LIKE '${SYSTEM_CRON_PREFIX}%'
+       GROUP BY r.status`).all();
+	const stats = {
+		running: 0,
+		completed: 0,
+		failed: 0,
+		total: 0
+	};
+	for (const row of rows) {
+		if (row.status === "running") stats.running = row.count;
+		else if (row.status === "success") stats.completed = row.count;
+		else if (row.status === "error") stats.failed = row.count;
+		stats.total += row.count;
+	}
+	return stats;
+}
+function deleteOldCronRuns(retentionDays) {
+	const result = getDb().prepare(`DELETE FROM cron_runs WHERE started_at < datetime('now', ? || ' days')`).run(`-${retentionDays}`);
+	return Number(result.changes);
+}
+function ensureSystemCronJob(name, schedule, prompt) {
+	if (getDb().prepare("SELECT uid FROM cron_jobs WHERE name = ?").get(name)) return;
+	const uid = generateUid(UID_PREFIX.bird);
+	getDb().prepare(`INSERT INTO cron_jobs (uid, name, schedule, prompt, agent_id) VALUES (?, ?, ?, ?, 'system')`).run(uid, name, schedule, prompt);
+}
+
+//#endregion
+//#region src/db/jobs.ts
+function createJob(options) {
+	const payload = options.payload != null ? JSON.stringify(options.payload) : null;
+	const priority = options.priority ?? "normal";
+	const maxAttempts = options.maxAttempts ?? 1;
+	const timeout = options.timeout ?? 1800;
+	const cronJobUid = options.cronJobUid ?? null;
+	if (options.delaySeconds) return getDb().prepare(`INSERT INTO jobs (name, payload, priority, max_attempts, timeout, cron_job_uid, run_at)
+         VALUES (?, ?, ?, ?, ?, ?, datetime('now', '+' || ? || ' seconds'))
+         RETURNING *`).get(options.name, payload, priority, maxAttempts, timeout, cronJobUid, options.delaySeconds);
+	return getDb().prepare(`INSERT INTO jobs (name, payload, priority, max_attempts, timeout, cron_job_uid)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`).get(options.name, payload, priority, maxAttempts, timeout, cronJobUid);
+}
+/**
+* Atomically claims the next pending job for processing.
+* Uses IMMEDIATE transaction to prevent race conditions.
+* Priority order: high > normal > low, then by creation time.
+*/
+function claimNextJob() {
+	return transaction(() => {
+		const row = getDb().prepare(`SELECT * FROM jobs
+         WHERE status = 'pending' AND (run_at IS NULL OR run_at <= datetime('now'))
+         ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'normal' THEN 1 WHEN 'low' THEN 2 END, created_at ASC
+         LIMIT 1`).get();
+		if (!row) return void 0;
+		getDb().prepare(`UPDATE jobs SET status = 'running', started_at = datetime('now'), attempts = attempts + 1
+         WHERE id = ?`).run(row.id);
+		return {
+			...row,
+			status: "running",
+			attempts: row.attempts + 1
+		};
+	});
+}
+function getJobStatus(jobId) {
+	return getDb().prepare("SELECT status FROM jobs WHERE id = ?").get(jobId)?.status;
+}
+function completeJob(jobId, result) {
+	getDb().prepare(`UPDATE jobs SET status = 'completed', completed_at = datetime('now'), result = ?
+       WHERE id = ?`).run(result ?? null, jobId);
+}
+function failJob(jobId, error) {
+	const job = getDb().prepare("SELECT attempts, max_attempts FROM jobs WHERE id = ?").get(jobId);
+	if (!job) return;
+	if (job.attempts < job.max_attempts) {
+		const delaySeconds = job.attempts * job.attempts;
+		getDb().prepare(`UPDATE jobs SET status = 'pending', error = ?,
+         run_at = datetime('now', '+' || ? || ' seconds')
+         WHERE id = ?`).run(error, delaySeconds, jobId);
+	} else getDb().prepare(`UPDATE jobs SET status = 'failed', completed_at = datetime('now'), error = ?
+         WHERE id = ?`).run(error, jobId);
+}
+/** Marks running jobs past their timeout as failed and cascades to linked cron_runs/cron_jobs. */
+function failStaleJobs() {
+	const d = getDb();
+	const staleRows = d.prepare(`SELECT id, cron_job_uid FROM jobs
+       WHERE status = 'running'
+         AND started_at < datetime('now', '-' || timeout || ' seconds')`).all();
+	if (staleRows.length === 0) return 0;
+	const updateJob = d.prepare(`UPDATE jobs SET status = 'failed', error = 'timeout', completed_at = datetime('now')
+     WHERE id = ?`);
+	const updateRun = d.prepare(`UPDATE cron_runs SET status = 'error', error = 'timeout', finished_at = datetime('now')
+     WHERE job_uid = ? AND status = 'running'`);
+	const updateBird = d.prepare(`UPDATE cron_jobs SET last_status = 'failed', failure_count = failure_count + 1
+     WHERE uid = ?`);
+	for (const row of staleRows) {
+		updateJob.run(row.id);
+		if (row.cron_job_uid != null) {
+			updateRun.run(row.cron_job_uid);
+			updateBird.run(row.cron_job_uid);
+		}
+	}
+	return staleRows.length;
+}
+function deleteOldJobs(retentionDays) {
+	const stmt = getDb().prepare(`DELETE FROM jobs WHERE status IN ('completed', 'failed')
+     AND completed_at < datetime('now', ? || ' days')`);
+	return Number(stmt.run(`-${retentionDays}`).changes);
+}
+const JOB_SORT_COLUMNS = new Set([
+	"id",
+	"name",
+	"status",
+	"priority",
+	"created_at",
+	"started_at"
+]);
+const JOB_SEARCH_COLUMNS = ["name", "error"];
+function listJobs(page = 1, perPage = DEFAULT_PER_PAGE, filters = {}, sort, search) {
+	const conditions = [];
+	const params = [];
+	if (filters.status) {
+		conditions.push("status = ?");
+		params.push(filters.status);
+	}
+	if (filters.cronJobUid != null) {
+		conditions.push("cron_job_uid = ?");
+		params.push(filters.cronJobUid);
+	}
+	if (filters.name) {
+		conditions.push("name LIKE ?");
+		params.push(`%${filters.name}%`);
+	}
+	return paginate("jobs", page, perPage, {
+		where: conditions.join(" AND "),
+		params,
+		defaultSort: "created_at DESC",
+		sort,
+		search,
+		allowedSortColumns: JOB_SORT_COLUMNS,
+		searchColumns: JOB_SEARCH_COLUMNS
+	});
+}
+function getJobStats() {
+	const rows = getDb().prepare("SELECT status, COUNT(*) as count FROM jobs GROUP BY status").all();
+	const stats = {
+		pending: 0,
+		running: 0,
+		completed: 0,
+		failed: 0,
+		total: 0
+	};
+	for (const row of rows) {
+		if (row.status in stats) stats[row.status] = row.count;
+		stats.total += row.count;
+	}
+	return stats;
+}
+function retryJob(jobId) {
+	const result = getDb().prepare(`UPDATE jobs SET status = 'pending', attempts = 0, error = NULL, result = NULL,
+       run_at = NULL, started_at = NULL, completed_at = NULL
+       WHERE id = ? AND status = 'failed'`).run(jobId);
+	return Number(result.changes) > 0;
+}
+function retryAllFailedJobs() {
+	const result = getDb().prepare(`UPDATE jobs SET status = 'pending', attempts = 0, error = NULL, result = NULL,
+       run_at = NULL, started_at = NULL, completed_at = NULL
+       WHERE status = 'failed'`).run();
+	return Number(result.changes);
+}
+function deleteJob(jobId) {
+	const result = getDb().prepare("DELETE FROM jobs WHERE id = ?").run(jobId);
+	return Number(result.changes) > 0;
+}
+function clearJobs(status) {
+	const result = getDb().prepare("DELETE FROM jobs WHERE status = ?").run(status);
+	return Number(result.changes);
+}
+/** Returns true if the given cron job has a pending or running job in the queue. */
+function hasPendingCronJob(cronJobUid) {
+	return getDb().prepare(`SELECT 1 FROM jobs WHERE cron_job_uid = ? AND status IN ('pending', 'running') LIMIT 1`).get(cronJobUid) != null;
+}
+
+//#endregion
+//#region src/db/messages.ts
+/** @fileoverview Message logging: message audit trail and token tracking. */
+function logMessage(channelId, threadId, userId, direction, content, tokensIn, tokensOut) {
+	getDb().prepare(`INSERT INTO messages (channel_id, thread_id, user_id, direction, content, tokens_in, tokens_out)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(channelId, threadId ?? null, userId, direction, content ?? null, tokensIn ?? null, tokensOut ?? null);
+}
+function getLastInboundMessage(channelId, threadId) {
+	const row = getDb().prepare(`SELECT content, created_at FROM messages
+       WHERE channel_id = ? AND thread_id IS ? AND direction = 'in' AND content IS NOT NULL
+       ORDER BY created_at DESC LIMIT 1`).get(channelId, threadId);
+	if (!row) return void 0;
+	return {
+		content: row.content,
+		timestamp: row.created_at
+	};
+}
+function deleteOldMessages(retentionDays) {
+	const result = getDb().prepare(`DELETE FROM messages WHERE created_at < datetime('now', ? || ' days')`).run(`-${retentionDays}`);
+	return Number(result.changes);
+}
+function getMessageStats() {
+	return getDb().prepare(`SELECT
+         COUNT(*) as totalMessages,
+         COALESCE(SUM(tokens_in), 0) as totalTokensIn,
+         COALESCE(SUM(tokens_out), 0) as totalTokensOut
+       FROM messages`).get();
+}
+
+//#endregion
+//#region src/db/logs.ts
+function insertLog(level, source, message, channelId) {
+	getDb().prepare(`INSERT INTO logs (level, source, message, channel_id) VALUES (?, ?, ?, ?)`).run(level, source, message, channelId ?? null);
+}
+const LOG_SORT_COLUMNS = new Set([
+	"id",
+	"level",
+	"source",
+	"created_at"
+]);
+const LOG_SEARCH_COLUMNS = ["message", "source"];
+function getRecentLogs(page = 1, perPage = DEFAULT_PER_PAGE, level, source, sort, search) {
+	const conditions = [];
+	const params = [];
+	if (level) {
+		conditions.push("level = ?");
+		params.push(level);
+	}
+	if (source) {
+		conditions.push("source = ?");
+		params.push(source);
+	}
+	return paginate("logs", page, perPage, {
+		where: conditions.join(" AND "),
+		params,
+		defaultSort: "created_at DESC",
+		sort,
+		search,
+		allowedSortColumns: LOG_SORT_COLUMNS,
+		searchColumns: LOG_SEARCH_COLUMNS
+	});
+}
+function deleteOldLogs(retentionDays) {
+	const stmt = getDb().prepare(`DELETE FROM logs WHERE created_at < datetime('now', ? || ' days')`);
+	return Number(stmt.run(`-${retentionDays}`).changes);
+}
+
+//#endregion
+//#region src/db/auth.ts
+/** @fileoverview User and settings persistence for the auth system. */
+function getUserCount() {
+	return getDb().prepare("SELECT COUNT(*) as count FROM users").get().count;
+}
+function getUserByEmail(email) {
+	return getDb().prepare("SELECT * FROM users WHERE email = ?").get(email);
+}
+function getUserById(id) {
+	return getDb().prepare("SELECT * FROM users WHERE id = ?").get(id);
+}
+function createUser(email, passwordHash, tokenKey) {
+	getDb().prepare("INSERT INTO users (email, password_hash, token_key) VALUES (?, ?, ?)").run(email, passwordHash, tokenKey);
+	return getUserByEmail(email);
+}
+function getSetting(key) {
+	return getDb().prepare("SELECT value FROM settings WHERE key = ?").get(key)?.value;
+}
+function setSetting(key, value) {
+	getDb().prepare("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(key, value);
+}
+
+//#endregion
+//#region src/db/feedback.ts
+/** @fileoverview Response feedback persistence (thumbs up/down). */
+function insertFeedback(channelId, threadId, messageTs, userId, value) {
+	getDb().prepare(`INSERT OR REPLACE INTO feedback (channel_id, thread_id, message_ts, user_id, value)
+       VALUES (?, ?, ?, ?, ?)`).run(channelId, threadId ?? null, messageTs ?? null, userId, value);
+}
+
+//#endregion
+//#region src/db/path.ts
+/** @fileoverview Database path resolution: CLI flag, env var, or default. */
+const DEFAULT_DB_PATH = resolve(".browserbird", "browserbird.db");
+/**
+* Resolves the database file path.
+* Priority: explicit value > BROWSERBIRD_DB env var > default.
+*/
+function resolveDbPath(explicit) {
+	if (explicit) return resolve(explicit);
+	const envValue = process.env["BROWSERBIRD_DB"];
+	if (envValue) return resolve(envValue);
+	return DEFAULT_DB_PATH;
+}
+/**
+* Extracts --db value from a raw argv array, then resolves.
+* Used by CLI command handlers that receive argv directly.
+*/
+function resolveDbPathFromArgv(argv) {
+	const idx = argv.indexOf("--db");
+	if (idx !== -1 && idx + 1 < argv.length) return resolveDbPath(argv[idx + 1]);
+	return resolveDbPath();
+}
+
 //#endregion
 //#region src/server/auth.ts
 /** @fileoverview Password hashing, token signing, and verification using node:crypto. */
@@ -2141,11 +3114,7 @@ function buildCommand(options) {
 		env
 	};
 }
-/**
-* Parses a single line of stream-json output into zero or more StreamEvents.
-* Only extracts text, images, completion, and error events. Tool use/result
-* events are internal to the agent and not surfaced to the channel layer.
-*/
+/** Parses a single line of stream-json output into zero or more StreamEvents. */
 function parseStreamLine(line) {
 	const trimmed = line.trim();
 	if (!trimmed || !trimmed.startsWith("{")) return [];
@@ -2166,7 +3135,7 @@ function parseStreamLine(line) {
 			}];
 			return [];
 		case "assistant": return parseAssistantContent(parsed);
-		case "user": return extractImages(parsed);
+		case "user": return parseUserContent(parsed);
 		case "result": {
 			const usage = parsed["usage"];
 			return [{
@@ -2216,23 +3185,36 @@ function parseAssistantContent(parsed) {
 			type: "text_delta",
 			delta: b["text"]
 		});
-		else if (b["type"] === "tool_use" && typeof b["name"] === "string") events.push({
-			type: "tool_use",
-			toolName: b["name"]
-		});
+		else if (b["type"] === "tool_use" && typeof b["name"] === "string") {
+			const input = b["input"];
+			events.push({
+				type: "tool_use",
+				toolName: b["name"],
+				toolCallId: typeof b["id"] === "string" ? b["id"] : void 0,
+				details: extractToolDetails(b["name"], input)
+			});
+		}
 	}
 	return events;
 }
-function extractImages(parsed) {
+function parseUserContent(parsed) {
 	const msg = parsed["message"];
 	if (!msg || typeof msg !== "object") return [];
 	const content = msg["content"];
 	if (!Array.isArray(content)) return [];
+	const events = [];
 	const images = [];
 	for (const block of content) {
 		if (!block || typeof block !== "object") continue;
 		const b = block;
 		if (b["type"] !== "tool_result") continue;
+		const toolUseId = b["tool_use_id"];
+		if (typeof toolUseId === "string") events.push({
+			type: "tool_result",
+			toolCallId: toolUseId,
+			isError: b["is_error"] === true,
+			output: extractToolOutput(b["content"])
+		});
 		const inner = b["content"];
 		if (!Array.isArray(inner)) continue;
 		for (const item of inner) {
@@ -2247,11 +3229,45 @@ function extractImages(parsed) {
 			});
 		}
 	}
-	if (images.length > 0) return [{
+	if (images.length > 0) events.push({
 		type: "tool_images",
 		images
-	}];
-	return [];
+	});
+	return events;
+}
+const MAX_DETAIL_LENGTH = 120;
+function truncate$1(text, max) {
+	return text.length > max ? text.slice(0, max - 3) + "..." : text;
+}
+function extractToolDetails(toolName, input) {
+	if (!input) return void 0;
+	if (toolName === "Bash") {
+		const desc = input["description"];
+		const cmd = input["command"];
+		return truncate$1(desc || cmd || "", MAX_DETAIL_LENGTH) || void 0;
+	}
+	if (toolName === "Read" || toolName === "Edit" || toolName === "Write") return input["file_path"] || void 0;
+	if (toolName === "Grep") {
+		const pattern = input["pattern"];
+		const path = input["path"];
+		if (!pattern) return void 0;
+		return path ? `${pattern} in ${path}` : pattern;
+	}
+	if (toolName === "Glob") return input["pattern"] || void 0;
+	if (toolName === "WebSearch") return input["query"] || void 0;
+	if (toolName === "WebFetch") return input["url"] || void 0;
+	if (toolName.startsWith("mcp__playwright__")) {
+		const url = input["url"];
+		if (url) return url;
+	}
+}
+function extractToolOutput(content) {
+	if (typeof content === "string") {
+		const lines = content.split("\n").filter((l) => l.trim());
+		if (lines.length === 0) return void 0;
+		if (lines.length === 1) return truncate$1(lines[0], MAX_DETAIL_LENGTH);
+		return `${lines.length} lines of output`;
+	}
 }
 
 //#endregion
@@ -2456,10 +3472,11 @@ function header(text) {
 		text: plain(text)
 	};
 }
-function section(text) {
+function section(text, opts) {
 	return {
 		type: "section",
-		text: mrkdwn(text)
+		text: mrkdwn(text),
+		...opts?.expand ? { expand: true } : {}
 	};
 }
 function fields(...pairs) {
@@ -2477,6 +3494,23 @@ function context(text) {
 		elements: [mrkdwn(text)]
 	};
 }
+function feedbackButtons() {
+	return {
+		type: "context_actions",
+		elements: [{
+			type: "feedback_buttons",
+			action_id: "response_feedback",
+			positive_button: {
+				text: plain("Good"),
+				value: "good"
+			},
+			negative_button: {
+				text: plain("Bad"),
+				value: "bad"
+			}
+		}]
+	};
+}
 const SUBTYPE_LABELS = {
 	error_max_turns: "Warning: Hit turn limit",
 	error_max_budget_usd: "Warning: Hit budget limit",
@@ -2498,7 +3532,12 @@ function completionFooterBlocks(completion, hasError, birdName, userId) {
 	parts.push(formatDuration(completion.durationMs));
 	parts.push(`${completion.numTurns} turn${completion.numTurns === 1 ? "" : "s"}`);
 	if (birdName) parts.push(birdName);
-	return [divider(), context(parts.join("  |  "))];
+	return [
+		divider(),
+		feedbackButtons(),
+		context(parts.join("  |  ")),
+		context("BrowserBird can hallucinate and may be inaccurate.")
+	];
 }
 /**
 * Standalone completion card for cron/bird results posted to a channel
@@ -2509,7 +3548,7 @@ function sessionCompleteBlocks(completion, summary, birdName, userId) {
 	const blocks = [header(completion.subtype === "success" ? "Session Complete" : "Session Ended"), fields(["Status", statusText], ["Duration", formatDuration(completion.durationMs)], ["Turns", String(completion.numTurns)])];
 	if (summary) {
 		const trimmed = summary.length > 2800 ? summary.slice(0, 2800) + "..." : summary;
-		blocks.push(section(`*Summary:*\n${trimmed}`));
+		blocks.push(section(`*Summary:*\n${trimmed}`, { expand: true }));
 	}
 	const contextParts = [];
 	if (birdName) contextParts.push(`Bird: *${birdName}*`);
@@ -2700,6 +3739,31 @@ function statusBlocks(opts) {
 	if (opts.runningBirds && opts.runningBirds.length > 0) result.push(section(`*In flight:* ${opts.runningBirds.join(", ")}`));
 	return result;
 }
+function homeTabView(opts) {
+	const blocks = [
+		header(opts.agentName),
+		section(opts.description),
+		divider(),
+		header("Scheduled Birds")
+	];
+	if (opts.birds.length === 0) blocks.push(section("No birds configured. Use `/bird create` to get started."));
+	else {
+		const lines = opts.birds.map((b) => {
+			return `[${b.enabled ? "on" : "off"}] *${b.name}* \`${b.schedule}\``;
+		});
+		blocks.push(section(lines.join("\n")));
+	}
+	blocks.push(divider(), header("Quick Commands"), section([
+		"`/bird list` -- show all birds",
+		"`/bird create` -- create a new bird",
+		"`/bird fly <name>` -- trigger a bird now",
+		"`/bird status` -- check system status"
+	].join("\n")), divider(), context(`${opts.activeSessions}/${opts.maxConcurrent} active sessions`));
+	return {
+		type: "home",
+		blocks
+	};
+}
 function truncate(text, maxLength) {
 	if (text.length <= maxLength) return text;
 	return text.slice(0, maxLength) + "...";
@@ -2793,7 +3857,11 @@ function startScheduler(getConfig, signal, deps) {
 				return "completed (no output)";
 			}
 			if (payload.channelId && deps?.postToSlack) {
-				await deps.postToSlack(payload.channelId, result);
+				const ts = await deps.postToSlack(payload.channelId, result);
+				if (ts && deps.setThreadTitle) {
+					const title = `${agent.name}: ${payload.prompt.slice(0, 60)}`;
+					deps.setThreadTitle(payload.channelId, ts, title).catch(() => {});
+				}
 				if (completion) {
 					const blocks = sessionCompleteBlocks(completion, void 0, agent.name);
 					const fallback = `Bird ${agent.name} completed: ${completion.numTurns} turns`;
@@ -2950,6 +4018,23 @@ function toolStatusText(toolName) {
 	if (toolName === "Edit" || toolName === "Write") return "is writing code...";
 	return "is working...";
 }
+function toolTaskTitle(toolName) {
+	if (toolName.startsWith(BROWSER_TOOL_PREFIX)) return `Browser: ${toolName.slice(17)}`;
+	if (toolName.startsWith("mcp__")) {
+		const parts = toolName.slice(5).split("__");
+		return `${parts[0] ?? "mcp"}: ${parts.slice(1).join("__") || "call"}`;
+	}
+	switch (toolName) {
+		case "Bash": return "Running command";
+		case "Read": return "Reading file";
+		case "Grep": return "Searching code";
+		case "Glob": return "Finding files";
+		case "Edit": return "Editing file";
+		case "Write": return "Writing file";
+		case "Agent": return "Running sub-agent";
+		default: return toolName;
+	}
+}
 function createHandler(client, getConfig, signal, getTeamId, getChannelNameToId) {
 	const locks = /* @__PURE__ */ new Map();
 	let activeSpawns = 0;
@@ -2984,6 +4069,8 @@ function createHandler(client, getConfig, signal, getTeamId, getChannelNameToId)
 		let hasError = false;
 		let timedOut = false;
 		let timedOutMs = 0;
+		const activeTasks = /* @__PURE__ */ new Map();
+		let toolCount = 0;
 		function isStreamExpired(err) {
 			const msg = err instanceof Error ? err.message : String(err);
 			return msg.includes("not_in_streaming_state") || msg.includes("streaming");
@@ -3033,7 +4120,40 @@ function createHandler(client, getConfig, signal, getTeamId, getChannelNameToId)
 					meta.onToolUse?.(event.toolName);
 					lastStatus = toolStatusText(event.toolName);
 					client.setStatus?.(channelId, threadTs, lastStatus).catch(() => {});
+					if (event.toolCallId !== void 0) {
+						toolCount++;
+						activeTasks.set(event.toolCallId, event.toolName);
+						const title = toolTaskTitle(event.toolName);
+						const chunks = [];
+						if (toolCount === 1) chunks.push({
+							type: "plan_update",
+							title: "Working on it"
+						});
+						chunks.push({
+							type: "task_update",
+							id: event.toolCallId,
+							title,
+							status: "in_progress",
+							...event.details ? { details: event.details } : {}
+						});
+						await safeAppend({ chunks });
+					}
+					break;
+				case "tool_result": {
+					const toolName = activeTasks.get(event.toolCallId);
+					if (toolName) {
+						activeTasks.delete(event.toolCallId);
+						const title = toolTaskTitle(toolName);
+						await safeAppend({ chunks: [{
+							type: "task_update",
+							id: event.toolCallId,
+							title,
+							status: event.isError ? "error" : "complete",
+							...event.output ? { output: event.output } : {}
+						}] });
+					}
 					break;
+				}
 				case "completion":
 					completion = event;
 					logger.info(`completion [${event.subtype}]: ${event.tokensIn}in/${event.tokensOut}out, $${event.costUsd.toFixed(4)}, ${event.numTurns} turns`);
@@ -3059,6 +4179,21 @@ function createHandler(client, getConfig, signal, getTeamId, getChannelNameToId)
 		}
 		clearInterval(statusTimer);
 		client.setStatus?.(channelId, threadTs, "").catch(() => {});
+		if (activeTasks.size > 0) {
+			const staleChunks = [];
+			for (const [id, toolName] of activeTasks) staleChunks.push({
+				type: "task_update",
+				id,
+				title: toolTaskTitle(toolName),
+				status: "error"
+			});
+			await safeAppend({ chunks: staleChunks });
+			activeTasks.clear();
+		}
+		if (toolCount > 0) await safeAppend({ chunks: [{
+			type: "plan_update",
+			title: hasError ? "Finished with errors" : `Completed (${toolCount} ${toolCount === 1 ? "step" : "steps"})`
+		}] });
 		if (timedOut) {
 			await safeStop({});
 			const blocks = sessionTimeoutBlocks(timedOutMs, { sessionUid });
@@ -3428,7 +4563,7 @@ var SlackChannelClient = class {
 			thread_ts: opts.threadTs,
 			recipient_team_id: opts.teamId,
 			recipient_user_id: opts.userId,
-			task_display_mode: "timeline",
+			task_display_mode: "plan",
 			buffer_size: 128
 		});
 	}
@@ -3446,11 +4581,12 @@ var SlackChannelClient = class {
 			title
 		});
 	}
-	async setSuggestedPrompts(channelId, threadTs, prompts) {
+	async setSuggestedPrompts(channelId, threadTs, prompts, title) {
 		await this.web.assistant.threads.setSuggestedPrompts({
 			channel_id: channelId,
 			thread_ts: threadTs,
-			prompts
+			prompts,
+			...title ? { title } : {}
 		});
 	}
 };
@@ -3572,6 +4708,20 @@ function createSlackChannel(getConfig, signal) {
 		}
 		coalescer.push(channelId, threadTs, userId, text, messageTs);
 	});
+	const DEFAULT_PROMPTS = [
+		{
+			title: "Browse a website",
+			message: "Browse https://example.com and summarize it"
+		},
+		{
+			title: "Run a command",
+			message: "List files in the current directory"
+		},
+		{
+			title: "Help me code",
+			message: "Help me write a function that..."
+		}
+	];
 	socketClient.on("assistant_thread_started", async ({ ack, event }) => {
 		await ack();
 		if (!event) return;
@@ -3580,23 +4730,54 @@ function createSlackChannel(getConfig, signal) {
 		const channelId = threadInfo["channel_id"];
 		const threadTs = threadInfo["thread_ts"];
 		if (!channelId || !threadTs) return;
-		channelClient.setSuggestedPrompts(channelId, threadTs, [
-			{
-				title: "Browse a website",
-				message: "Browse https://example.com and summarize it"
-			},
-			{
-				title: "Run a command",
-				message: "List files in the current directory"
-			},
-			{
-				title: "Help me code",
-				message: "Help me write a function that..."
-			}
-		]).catch(() => {});
+		const agent = matchAgent(channelId, getConfig().agents, channelNameToId);
+		const prompts = agent?.suggestedPrompts ?? DEFAULT_PROMPTS;
+		const promptTitle = `What can ${agent?.name ?? "BrowserBird"} help with?`;
+		channelClient.setSuggestedPrompts?.(channelId, threadTs, prompts, promptTitle).catch(() => {});
 	});
-	socketClient.on("assistant_thread_context_changed", async ({ ack }) => {
+	socketClient.on("assistant_thread_context_changed", async ({ ack, event }) => {
 		await ack();
+		if (!event) return;
+		const threadInfo = event["assistant_thread"];
+		if (!threadInfo) return;
+		const channelId = threadInfo["channel_id"];
+		const threadTs = threadInfo["thread_ts"];
+		if (!channelId || !threadTs) return;
+		const contextChannelId = threadInfo["context"]?.["channel_id"];
+		const config = getConfig();
+		const agent = matchAgent(contextChannelId ?? channelId, config.agents, channelNameToId);
+		const prompts = agent?.suggestedPrompts ?? DEFAULT_PROMPTS;
+		const promptTitle = `What can ${agent?.name ?? "BrowserBird"} help with?`;
+		channelClient.setSuggestedPrompts?.(channelId, threadTs, prompts, promptTitle).catch(() => {});
+	});
+	socketClient.on("app_home_opened", async ({ ack, event }) => {
+		await ack();
+		if (!event) return;
+		const userId = event["user"];
+		if (!userId) return;
+		if (event["tab"] !== "home") return;
+		try {
+			const config = getConfig();
+			const agent = config.agents[0];
+			const birds = listCronJobs(1, 20).items.map((b) => ({
+				name: b.name,
+				schedule: b.schedule,
+				enabled: b.enabled === 1
+			}));
+			const view = homeTabView({
+				agentName: agent?.name ?? "BrowserBird",
+				description: agent?.systemPrompt ?? "A self-hosted AI assistant with a real browser and a scheduler.",
+				birds,
+				activeSessions: handler.activeCount(),
+				maxConcurrent: config.sessions.maxConcurrent
+			});
+			await webClient.views.publish({
+				user_id: userId,
+				view
+			});
+		} catch (err) {
+			logger.warn(`home tab error: ${err instanceof Error ? err.message : String(err)}`);
+		}
 	});
 	let connected = false;
 	const statusProvider = {
@@ -3634,6 +4815,16 @@ function createSlackChannel(getConfig, signal) {
 					if (!sessionUid) continue;
 					await handleSessionRetry(sessionUid, user ?? "unknown", handler);
 				}
+				if (actionId === "response_feedback") {
+					const value = action["value"];
+					if (value === "good" || value === "bad") {
+						const message = body["message"];
+						const threadTs = message?.["thread_ts"];
+						const messageTs = message?.["ts"];
+						insertFeedback(channel, threadTs, messageTs, user ?? "unknown", value);
+						logger.info(`feedback: ${value} from ${user} in ${channel}`);
+					}
+				}
 			}
 		}
 	});
@@ -3711,11 +4902,14 @@ function createSlackChannel(getConfig, signal) {
 		return connected;
 	}
 	async function postMessage(channel, text, opts) {
-		await webClient.chat.postMessage({
+		return (await webClient.chat.postMessage({
 			channel,
 			text,
 			...opts?.blocks ? { blocks: opts.blocks } : {}
-		});
+		})).ts ?? "";
+	}
+	async function setTitle(channelId, threadTs, title) {
+		await channelClient.setTitle(channelId, threadTs, title);
 	}
 	return {
 		start,
@@ -3723,6 +4917,7 @@ function createSlackChannel(getConfig, signal) {
 		isConnected,
 		activeCount: () => handler.activeCount(),
 		postMessage,
+		setTitle,
 		resolveChannelNames
 	};
 }
@@ -3738,7 +4933,6 @@ async function handleBirdCreateSubmission(view, webClient) {
 			logger.warn("bird_create submission missing required fields");
 			return;
 		}
-		const { createCronJob, setCronJobEnabled } = await import("./db-BNF1vZIm.mjs").then((n) => n.t);
 		const bird = createCronJob(name, schedule, prompt, channelId || void 0, "default");
 		if (enabledValue !== "enabled") setCronJobEnabled(bird.uid, false);
 		await webClient.chat.postMessage({
@@ -3752,7 +4946,6 @@ async function handleBirdCreateSubmission(view, webClient) {
 }
 async function handleSessionRetry(sessionUid, userId, handler) {
 	try {
-		const { getSession, getLastInboundMessage } = await import("./db-BNF1vZIm.mjs").then((n) => n.t);
 		const session = getSession(sessionUid);
 		if (!session) {
 			logger.warn(`retry: session ${sessionUid} not found`);
@@ -3851,7 +5044,10 @@ async function startDaemon(options) {
 		currentConfig = config;
 		if (!schedulerStarted && config.agents.length > 0) {
 			logger.info("starting scheduler...");
-			startScheduler(getConfig, controller.signal, { postToSlack: (channel, text, opts) => slackHandle ? slackHandle.postMessage(channel, text, opts) : Promise.resolve() });
+			startScheduler(getConfig, controller.signal, {
+				postToSlack: (channel, text, opts) => slackHandle ? slackHandle.postMessage(channel, text, opts) : Promise.resolve(""),
+				setThreadTitle: (channelId, threadTs, title) => slackHandle ? slackHandle.setTitle(channelId, threadTs, title) : Promise.resolve()
+			});
 			schedulerStarted = true;
 		}
 		if (!healthStarted) {