@owloops/browserbird 1.0.2 → 1.0.3

package/dist/index.mjs

@@ -0,0 +1,4748 @@
+import { $ as updateSessionProviderId, A as completeCronRun, B as listFlights, C as failStaleJobs, D as retryAllFailedJobs, E as listJobs, F as ensureSystemCronJob, G as deleteStaleSessions, H as updateCronJob, I as getCronJob, J as getSessionCount, K as findSession, L as getEnabledCronJobs, M as createCronRun, N as deleteCronJob, O as retryJob, P as deleteOldCronRuns, Q as touchSession, R as getFlightStats, S as failJob, T as hasPendingCronJob, U as updateCronJobStatus, V as setCronJobEnabled, W as createSession, X as getSessionTokenStats, Y as getSessionMessages, Z as listSessions, _ as clearJobs, a as getSetting, at as logger, b as deleteJob, c as getUserCount, d as getRecentLogs, et as shortUid, f as insertLog, g as claimNextJob, h as logMessage, i as createUser, it as resolveByUid, j as createCronJob, k as SYSTEM_CRON_PREFIX, l as setSetting, m as getMessageStats, n as resolveDbPath, nt as openDatabase, o as getUserByEmail, p as deleteOldMessages, q as getSession, r as resolveDbPathFromArgv, rt as optimizeDatabase, s as getUserById, tt as closeDatabase, u as deleteOldLogs, v as completeJob, w as getJobStats, x as deleteOldJobs, y as createJob, z as listCronJobs } from "./db-BsYEYsul.mjs";
+import { createRequire } from "node:module";
+import { parseArgs, styleText } from "node:util";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { createHmac, randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { connect } from "node:net";
+import { execFileSync, spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { fileURLToPath } from "node:url";
+import { SocketModeClient } from "@slack/socket-mode";
+import { LogLevel, WebClient } from "@slack/web-api";
+
+//#region src/core/types.ts
+const COMMANDS = {
+	SESSIONS: "sessions",
+	BIRDS: "birds",
+	CONFIG: "config",
+	LOGS: "logs",
+	JOBS: "jobs",
+	DOCTOR: "doctor"
+};
+
+//#endregion
+//#region src/core/utils.ts
+/** @fileoverview Shared utilities: formatting, time ranges, and CLI table output. */
+const BIRD_NAME_MAX_LENGTH = 50;
+function formatDuration(ms) {
+	const totalSeconds = Math.round(ms / 1e3);
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (minutes === 0) return `${seconds}s`;
+	return `${minutes}m ${seconds}s`;
+}
+function deriveBirdName(prompt) {
+	return prompt.trim().slice(0, BIRD_NAME_MAX_LENGTH);
+}
+/**
+* Returns true if the current time in the given timezone falls within a HH:MM time range.
+* Handles wrap-around ranges (e.g. 22:00-06:00 spanning midnight).
+*/
+function isWithinTimeRange(start, end, date, timezone) {
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		hour: "numeric",
+		minute: "numeric",
+		hour12: false
+	}).formatToParts(date);
+	const h = Number(parts.find((p) => p.type === "hour")?.value ?? 0);
+	const m = Number(parts.find((p) => p.type === "minute")?.value ?? 0);
+	const nowMinutes = h * 60 + m;
+	const startMinutes = parseHHMM(start);
+	const endMinutes = parseHHMM(end);
+	if (startMinutes <= endMinutes) return nowMinutes >= startMinutes && nowMinutes < endMinutes;
+	return nowMinutes >= startMinutes || nowMinutes < endMinutes;
+}
+function parseHHMM(s) {
+	const [hh, mm] = s.split(":");
+	const h = Number(hh);
+	const m = Number(mm ?? 0);
+	if (!Number.isFinite(h) || !Number.isFinite(m)) return 0;
+	return h * 60 + m;
+}
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function visibleLength(s) {
+	return s.replace(ANSI_RE, "").length;
+}
+/** Print a formatted table with auto-calculated column widths to stdout. */
+function printTable(headers, rows, maxWidths) {
+	const widths = headers.map((h) => h.length);
+	for (const row of rows) for (let i = 0; i < row.length; i++) {
+		const cellLen = visibleLength(row[i] ?? "");
+		const maxW = maxWidths?.[i];
+		const capped = maxW != null ? Math.min(cellLen, maxW) : cellLen;
+		widths[i] = Math.max(widths[i] ?? 0, capped);
+	}
+	function pad(s, width, max) {
+		const vis = visibleLength(s);
+		const truncated = max != null && vis > max ? s.slice(0, max - 3) + "..." : s;
+		const padLen = width - visibleLength(truncated);
+		return padLen > 0 ? truncated + " ".repeat(padLen) : truncated;
+	}
+	const indent = "  ";
+	console.log(indent + headers.map((h, i) => pad(h, widths[i])).join("  "));
+	console.log(indent + widths.map((w) => "-".repeat(w)).join("  "));
+	for (const row of rows) console.log(indent + row.map((cell, i) => pad(cell ?? "", widths[i], maxWidths?.[i])).join("  "));
+}
+function levenshtein(a, b) {
+	const m = a.length;
+	const n = b.length;
+	const dp = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
+	for (let i = 0; i <= m; i++) dp[i][0] = i;
+	for (let j = 0; j <= n; j++) dp[0][j] = j;
+	for (let i = 1; i <= m; i++) for (let j = 1; j <= n; j++) {
+		const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+		dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+	}
+	return dp[m][n];
+}
+function unknownSubcommand(subcommand, command, validCommands) {
+	const label = command ? "subcommand" : "command";
+	process.stderr.write(`error: unknown ${label}: ${subcommand}\n`);
+	if (validCommands && validCommands.length > 0) {
+		let bestMatch = "";
+		let bestDist = Infinity;
+		for (const cmd of validCommands) {
+			const dist = levenshtein(subcommand, cmd);
+			if (dist < bestDist) {
+				bestDist = dist;
+				bestMatch = cmd;
+			}
+		}
+		if (bestDist <= 2 && bestMatch) process.stderr.write(`did you mean '${bestMatch}'?\n`);
+	}
+	const helpCmd = command ? `browserbird ${command} --help` : "browserbird --help";
+	process.stderr.write(`run '${helpCmd}' for usage\n`);
+	process.exitCode = 1;
+}
+
+//#endregion
+//#region src/cli/banner.ts
+/** @fileoverview ASCII banner displayed on daemon startup and in help text. */
+const pkg = createRequire(import.meta.url)("../package.json");
+const buildInfo = [];
+buildInfo.push(`commit: ${"8508da3ffdb3230ea117b27463cc293726074f06".substring(0, 7)}`);
+const buildString = buildInfo.length > 0 ? ` (${buildInfo.join(", ")})` : "";
+const VERSION = `browserbird ${pkg.version}${buildString}`;
+const BIRD = [
+	"   .__.",
+	"   ( ^>",
+	"   / )\\",
+	"  <_/_/",
+	"   \" \""
+].join("\n");
+const BANNER = BIRD;
+
+//#endregion
+//#region src/config.ts
+/** @fileoverview Configuration loading from JSON with env: variable resolution. */
+const VALID_PROVIDERS$1 = new Set(["claude", "opencode"]);
+const DEFAULTS = {
+	timezone: "UTC",
+	slack: {
+		botToken: "",
+		appToken: "",
+		requireMention: true,
+		coalesce: {
+			debounceMs: 3e3,
+			bypassDms: true
+		},
+		channels: ["*"],
+		quietHours: {
+			enabled: false,
+			start: "23:00",
+			end: "08:00",
+			timezone: "UTC"
+		}
+	},
+	agents: [{
+		id: "default",
+		name: "BrowserBird",
+		provider: "claude",
+		model: "sonnet",
+		maxTurns: 50,
+		systemPrompt: "You are responding in a Slack workspace. Be concise, helpful, and natural.",
+		channels: ["*"]
+	}],
+	sessions: {
+		ttlHours: 24,
+		maxConcurrent: 5,
+		processTimeoutMs: 3e5
+	},
+	database: { retentionDays: 30 },
+	browser: {
+		enabled: false,
+		mcpConfigPath: void 0,
+		vncPort: 5900,
+		novncPort: 6080,
+		novncHost: "localhost"
+	},
+	birds: { maxAttempts: 3 },
+	web: {
+		enabled: true,
+		host: "127.0.0.1",
+		port: 18800,
+		corsOrigin: ""
+	}
+};
+/**
+* Resolves `"env:VAR_NAME"` strings to their environment variable values.
+* Throws if the env var is not set.
+*/
+function resolveEnvValue(value) {
+	if (typeof value === "string" && value.startsWith("env:")) {
+		const envKey = value.slice(4);
+		const envValue = process.env[envKey];
+		if (envValue == null) throw new Error(`Environment variable ${envKey} is not set (referenced as "${value}")`);
+		return envValue;
+	}
+	if (Array.isArray(value)) return value.map(resolveEnvValue);
+	if (value !== null && typeof value === "object") return resolveEnvValues(value);
+	return value;
+}
+function resolveEnvValues(obj) {
+	const resolved = {};
+	for (const [key, value] of Object.entries(obj)) resolved[key] = resolveEnvValue(value);
+	return resolved;
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const [key, value] of Object.entries(source)) {
+		const targetValue = target[key];
+		if (value !== null && typeof value === "object" && !Array.isArray(value) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) result[key] = deepMerge(targetValue, value);
+		else result[key] = value;
+	}
+	return result;
+}
+/**
+* Loads configuration from a JSON file, merges with defaults, and resolves env: references.
+* Searches for browserbird.json in the current directory, then falls back to defaults.
+*/
+function loadConfig(configPath) {
+	const filePath = configPath ?? resolve("browserbird.json");
+	if (!existsSync(filePath)) {
+		logger.warn(`no config file found at ${filePath}, using defaults`);
+		return DEFAULTS;
+	}
+	logger.info(`loading config from ${filePath}`);
+	const raw = readFileSync(filePath, "utf-8");
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Failed to parse config file: ${filePath}`);
+	}
+	const config = resolveEnvValues(deepMerge(DEFAULTS, parsed));
+	validateConfig(config);
+	return config;
+}
+/** Validates merged config and throws on invalid values, warns on risky combinations. */
+function validateConfig(config) {
+	if (!Array.isArray(config.agents) || config.agents.length === 0) throw new Error("at least one agent must be configured");
+	for (const agent of config.agents) {
+		if (!agent.id || !agent.name) throw new Error("each agent must have an \"id\" and \"name\"");
+		if (!VALID_PROVIDERS$1.has(agent.provider)) throw new Error(`agent "${agent.id}": unknown provider "${agent.provider}" (expected: ${[...VALID_PROVIDERS$1].join(", ")})`);
+		if (!agent.model) throw new Error(`agent "${agent.id}": "model" is required`);
+		if (!Array.isArray(agent.channels) || agent.channels.length === 0) throw new Error(`agent "${agent.id}": "channels" must be a non-empty array`);
+		if (agent.fallbackModel && agent.fallbackModel === agent.model) throw new Error(`agent "${agent.id}": fallbackModel cannot be the same as model ("${agent.model}")`);
+	}
+	const browserMode = process.env["BROWSER_MODE"] ?? "persistent";
+	if (config.browser.enabled && browserMode === "persistent" && config.sessions.maxConcurrent > 1) logger.warn("persistent browser mode with maxConcurrent > 1 will cause lock contention; use \"isolated\" or set maxConcurrent to 1");
+}
+/**
+* Reads and merges JSON config with DEFAULTS but skips env: resolution.
+* Returns raw config data suitable for reading/modifying before writing back.
+*/
+function loadRawConfig(configPath) {
+	const filePath = configPath ?? resolve("browserbird.json");
+	if (!existsSync(filePath)) return JSON.parse(JSON.stringify(DEFAULTS));
+	const raw = readFileSync(filePath, "utf-8");
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		throw new Error(`Failed to parse config file: ${filePath}`);
+	}
+	return deepMerge(DEFAULTS, parsed);
+}
+/**
+* Checks whether both Slack tokens are present and resolvable.
+* Literal strings must be non-empty; `"env:VAR"` references must point to a set env var.
+*/
+function hasSlackTokens(configPath) {
+	const filePath = configPath ?? resolve("browserbird.json");
+	if (!existsSync(filePath)) return false;
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+	} catch {
+		return false;
+	}
+	const slack = parsed["slack"];
+	if (!slack) return false;
+	return isTokenResolvable(slack["botToken"]) && isTokenResolvable(slack["appToken"]);
+}
+function isTokenResolvable(value) {
+	if (typeof value !== "string" || !value) return false;
+	if (value.startsWith("env:")) {
+		const envKey = value.slice(4);
+		return !!process.env[envKey];
+	}
+	return true;
+}
+/** Atomic write: writes to a .tmp file then renames over the target. */
+function saveConfig(configPath, data) {
+	const tmp = configPath + ".tmp";
+	writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	renameSync(tmp, configPath);
+}
+/**
+* Reads an existing .env file, updates/appends entries, and writes atomically.
+* Preserves comments, blank lines, and ordering of existing entries.
+*/
+function saveEnvFile(envPath, vars) {
+	const remaining = new Map(Object.entries(vars));
+	const lines = [];
+	if (existsSync(envPath)) {
+		const content = readFileSync(envPath, "utf-8");
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) {
+				lines.push(line);
+				continue;
+			}
+			const eqIdx = trimmed.indexOf("=");
+			if (eqIdx === -1) {
+				lines.push(line);
+				continue;
+			}
+			const key = trimmed.slice(0, eqIdx).trim();
+			if (remaining.has(key)) {
+				lines.push(`${key}=${remaining.get(key)}`);
+				remaining.delete(key);
+			} else lines.push(line);
+		}
+	}
+	for (const [key, value] of remaining) lines.push(`${key}=${value}`);
+	const finalContent = lines.join("\n").replace(/\n{3,}/g, "\n\n");
+	const tmp = envPath + ".tmp";
+	writeFileSync(tmp, finalContent.endsWith("\n") ? finalContent : finalContent + "\n", "utf-8");
+	renameSync(tmp, envPath);
+}
+/**
+* Reads a .env file and injects entries into process.env.
+* Handles comments, blank lines, and optionally quoted values.
+*/
+function loadDotEnv(envPath) {
+	if (!existsSync(envPath)) return;
+	const content = readFileSync(envPath, "utf-8");
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIdx = trimmed.indexOf("=");
+		if (eqIdx === -1) continue;
+		const key = trimmed.slice(0, eqIdx).trim();
+		let value = trimmed.slice(eqIdx + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		process.env[key] = value;
+	}
+}
+
+//#endregion
+//#region src/server/auth.ts
+/** @fileoverview Password hashing, token signing, and verification using node:crypto. */
+const SCRYPT_N = 16384;
+const SCRYPT_R = 8;
+const SCRYPT_P = 1;
+const SCRYPT_KEYLEN = 64;
+const SALT_BYTES = 16;
+const TOKEN_EXPIRY_MS = 10080 * 60 * 1e3;
+function hashPassword(password) {
+	return new Promise((resolve, reject) => {
+		const salt = randomBytes(SALT_BYTES);
+		scrypt(password, salt, SCRYPT_KEYLEN, {
+			N: SCRYPT_N,
+			r: SCRYPT_R,
+			p: SCRYPT_P
+		}, (err, key) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+			resolve(`scrypt$${SCRYPT_N}$${SCRYPT_R}$${SCRYPT_P}$${salt.toString("hex")}$${key.toString("hex")}`);
+		});
+	});
+}
+function verifyPassword(password, stored) {
+	return new Promise((resolve, reject) => {
+		const parts = stored.split("$");
+		if (parts.length !== 6 || parts[0] !== "scrypt") {
+			resolve(false);
+			return;
+		}
+		const n = Number(parts[1]);
+		const r = Number(parts[2]);
+		const p = Number(parts[3]);
+		const salt = Buffer.from(parts[4], "hex");
+		const expected = Buffer.from(parts[5], "hex");
+		scrypt(password, salt, expected.length, {
+			N: n,
+			r,
+			p
+		}, (err, key) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+			resolve(timingSafeEqual(key, expected));
+		});
+	});
+}
+function generateTokenKey() {
+	return randomBytes(32).toString("hex");
+}
+function getOrCreateSecret() {
+	const existing = getSetting("auth_secret");
+	if (existing) return existing;
+	const secret = randomBytes(32).toString("hex");
+	setSetting("auth_secret", secret);
+	return secret;
+}
+function base64UrlEncode(data) {
+	return Buffer.from(data).toString("base64url");
+}
+function base64UrlDecode(encoded) {
+	return Buffer.from(encoded, "base64url").toString();
+}
+function hmacSign(data, key) {
+	return createHmac("sha256", key).update(data).digest("base64url");
+}
+function signToken(userId, tokenKey, secret) {
+	const now = Date.now();
+	const header = base64UrlEncode(JSON.stringify({
+		alg: "HS256",
+		typ: "JWT"
+	}));
+	const payload = base64UrlEncode(JSON.stringify({
+		sub: userId,
+		exp: now + TOKEN_EXPIRY_MS,
+		iat: now,
+		jti: randomBytes(16).toString("hex")
+	}));
+	const signingKey = tokenKey + secret;
+	return `${header}.${payload}.${hmacSign(`${header}.${payload}`, signingKey)}`;
+}
+/**
+* Verifies a raw token string: structure, signature, expiry, and that the
+* user still exists in the DB. Returns true if valid, false otherwise.
+*/
+function verifyToken(token) {
+	const parts = token.split(".");
+	if (parts.length !== 3) return false;
+	let sub;
+	try {
+		const decoded = JSON.parse(base64UrlDecode(parts[1]));
+		if (typeof decoded.sub !== "number") return false;
+		sub = decoded.sub;
+	} catch {
+		return false;
+	}
+	const user = getUserById(sub);
+	if (!user) return false;
+	const secret = getOrCreateSecret();
+	const [header, payload, signature] = parts;
+	const signingKey = user.token_key + secret;
+	const expected = hmacSign(`${header}.${payload}`, signingKey);
+	const sigBuf = Buffer.from(signature, "base64url");
+	const expBuf = Buffer.from(expected, "base64url");
+	if (sigBuf.length !== expBuf.length || !timingSafeEqual(sigBuf, expBuf)) return false;
+	try {
+		const decoded = JSON.parse(base64UrlDecode(payload));
+		if (typeof decoded.exp !== "number" || decoded.exp < Date.now()) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/server/http.ts
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2"
+};
+function pathToRegex(path) {
+	const pattern = path.replace(/:(\w+)/g, "(?<$1>[^/]+)");
+	return new RegExp(`^${pattern}$`);
+}
+function json(res, data, status = 200) {
+	const body = JSON.stringify(data);
+	res.writeHead(status, {
+		"Content-Type": "application/json; charset=utf-8",
+		"Content-Length": Buffer.byteLength(body)
+	});
+	res.end(body);
+}
+function jsonError(res, message, status) {
+	json(res, { error: message }, status);
+}
+function parsePagination(url) {
+	return {
+		page: Math.max(Number(url.searchParams.get("page")) || 1, 1),
+		perPage: Math.max(Number(url.searchParams.get("perPage")) || 20, 1)
+	};
+}
+function parseSystemFlag(url) {
+	return url.searchParams.get("system") === "true";
+}
+function parseSortParam(url) {
+	return url.searchParams.get("sort") ?? void 0;
+}
+function parseSearchParam(url) {
+	return url.searchParams.get("search") ?? void 0;
+}
+const MAX_BODY_BYTES = 1024 * 1024;
+async function readJsonBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let totalBytes = 0;
+		req.on("data", (chunk) => {
+			totalBytes += chunk.length;
+			if (totalBytes > MAX_BODY_BYTES) {
+				req.destroy();
+				reject(/* @__PURE__ */ new Error("Request body too large"));
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			try {
+				resolve(JSON.parse(Buffer.concat(chunks).toString()));
+			} catch {
+				reject(/* @__PURE__ */ new Error("Invalid JSON body"));
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function extractToken(req, allowQueryToken) {
+	const authHeader = req.headers["authorization"] ?? "";
+	if (authHeader.startsWith("Bearer ")) return authHeader.slice(7);
+	if (allowQueryToken) return new URL(req.url ?? "/", `http://${req.headers.host}`).searchParams.get("token");
+	return null;
+}
+/**
+* Verifies the request is authenticated. In setup mode (no users in DB),
+* all requests are allowed. Otherwise, a valid signed token is required.
+*/
+function checkAuth(req, res, allowQueryToken = false) {
+	if (getUserCount() === 0) return true;
+	const token = extractToken(req, allowQueryToken);
+	if (!token || !verifyToken(token)) {
+		jsonError(res, "Unauthorized", 401);
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/cli/style.ts
+/** @fileoverview CLI color utilities. Safe palette per terminal theme compatibility. */
+function shouldUseColor() {
+	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;
+}
+const useColor = shouldUseColor();
+function c(format, text) {
+	if (!useColor) return text;
+	return styleText(format, text);
+}
+
+//#endregion
+//#region src/cli/doctor.ts
+/** @fileoverview Doctor command: checks system dependencies. */
+const DOCTOR_HELP = `
+${c("cyan", "usage:")} browserbird doctor
+
+check system dependencies (agent clis, node.js).
+`.trim();
+function checkCli(binary, versionArgs) {
+	try {
+		return {
+			available: true,
+			version: (execFileSync(binary, versionArgs, {
+				timeout: 5e3,
+				encoding: "utf-8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim().split("\n")[0] ?? "").replace(/\s*\(.*\)$/, "") || null
+		};
+	} catch {
+		return {
+			available: false,
+			version: null
+		};
+	}
+}
+function checkDoctor() {
+	return {
+		claude: checkCli("claude", ["--version"]),
+		opencode: checkCli("opencode", ["--version"]),
+		node: process.version
+	};
+}
+function handleDoctor() {
+	const result = checkDoctor();
+	console.log(c("cyan", "doctor"));
+	console.log(c("dim", "------"));
+	if (result.claude.available) logger.success(`claude cli: ${result.claude.version}`);
+	else {
+		logger.error("claude cli: not found");
+		process.stderr.write("  install: npm install -g @anthropic-ai/claude-code\n");
+	}
+	if (result.opencode.available) logger.success(`opencode cli: ${result.opencode.version}`);
+	else {
+		logger.warn("opencode cli: not found (optional)");
+		process.stderr.write("  install: npm install -g opencode\n");
+	}
+	logger.success(`node.js: ${result.node}`);
+}
+
+//#endregion
+//#region src/server/health.ts
+/** @fileoverview Cached service health checks for agent CLI and browser connectivity. */
+const AGENT_CHECK_INTERVAL_MS = 6e4;
+const BROWSER_CHECK_INTERVAL_MS = 5e3;
+const BROWSER_PROBE_TIMEOUT_MS = 2e3;
+let agentAvailable = false;
+let agentCheckedAt = 0;
+let browserConnected = false;
+let browserCheckPending = false;
+function refreshAgent(config) {
+	const now = Date.now();
+	if (now - agentCheckedAt < AGENT_CHECK_INTERVAL_MS) return;
+	const result = checkDoctor();
+	agentAvailable = [...new Set(config.agents.map((a) => a.provider))].some((p) => result[p]?.available === true);
+	agentCheckedAt = now;
+}
+function probeBrowser(host, port) {
+	return new Promise((resolve) => {
+		const socket = connect(port, host, () => {
+			socket.destroy();
+			resolve(true);
+		});
+		socket.setTimeout(BROWSER_PROBE_TIMEOUT_MS);
+		socket.on("timeout", () => {
+			socket.destroy();
+			resolve(false);
+		});
+		socket.on("error", () => {
+			socket.destroy();
+			resolve(false);
+		});
+	});
+}
+function refreshBrowser(config) {
+	if (!config.browser.enabled || browserCheckPending) return;
+	browserCheckPending = true;
+	probeBrowser(config.browser.novncHost, config.browser.novncPort).then((ok) => {
+		browserConnected = ok;
+	}).catch(() => {
+		browserConnected = false;
+	}).finally(() => {
+		browserCheckPending = false;
+	});
+}
+function getServiceHealth(config) {
+	refreshAgent(config);
+	return {
+		agent: { available: agentAvailable },
+		browser: { connected: config.browser.enabled ? browserConnected : false }
+	};
+}
+function startHealthChecks(config, signal) {
+	refreshAgent(config);
+	refreshBrowser(config);
+	const timer = setInterval(() => {
+		refreshBrowser(config);
+	}, BROWSER_CHECK_INTERVAL_MS);
+	signal.addEventListener("abort", () => {
+		clearInterval(timer);
+	});
+	logger.debug("health checks started");
+}
+
+//#endregion
+//#region src/cron/parse.ts
+/** @fileoverview Cron expression parser. Standard 5-field syntax + common macros. */
+const MACROS = {
+	"@yearly": "0 0 1 1 *",
+	"@annually": "0 0 1 1 *",
+	"@monthly": "0 0 1 * *",
+	"@weekly": "0 0 * * 0",
+	"@daily": "0 0 * * *",
+	"@midnight": "0 0 * * *",
+	"@hourly": "0 * * * *"
+};
+/**
+* Parses a single cron field (e.g. `"*"`, `"1,5,10"`, `"9-17"`, `"* /15"`).
+* Returns a Set of integer values that match.
+*/
+function parseField(field, min, max) {
+	const values = /* @__PURE__ */ new Set();
+	for (const part of field.split(",")) {
+		const stepParts = part.split("/");
+		const range = stepParts[0];
+		const step = stepParts[1] != null ? parseInt(stepParts[1], 10) : 1;
+		let start;
+		let end;
+		if (range === "*") {
+			start = min;
+			end = max;
+		} else if (range.includes("-")) {
+			const [lo, hi] = range.split("-");
+			start = parseInt(lo, 10);
+			end = parseInt(hi, 10);
+		} else {
+			start = parseInt(range, 10);
+			end = start;
+		}
+		for (let i = start; i <= end; i += step) values.add(i);
+	}
+	return values;
+}
+/** Parses a cron expression string into a CronSchedule. */
+function parseCron(expression) {
+	const fields = (MACROS[expression.toLowerCase()] ?? expression).trim().split(/\s+/);
+	if (fields.length !== 5) throw new Error(`invalid cron expression: expected 5 fields, got ${fields.length}`);
+	return {
+		minutes: parseField(fields[0], 0, 59),
+		hours: parseField(fields[1], 0, 23),
+		daysOfMonth: parseField(fields[2], 1, 31),
+		months: parseField(fields[3], 1, 12),
+		daysOfWeek: parseField(fields[4], 0, 6)
+	};
+}
+/**
+* Returns true if the current time falls within the active hours window.
+* When both start and end are null, the bird is always active.
+* Hours are evaluated in the bird's configured timezone.
+*/
+function isWithinActiveHours(start, end, date, timezone) {
+	if (start == null && end == null) return true;
+	return isWithinTimeRange(start ?? "00:00", end ?? "24:00", date, timezone || "UTC");
+}
+/**
+* Returns the next Date (after `after`) that matches the cron schedule,
+* or null if no match is found within the search window (default: 366 days).
+*/
+function nextCronMatch(schedule, after, timezone, maxMinutes = 527040) {
+	const candidate = new Date(after.getTime());
+	candidate.setSeconds(0, 0);
+	candidate.setTime(candidate.getTime() + 6e4);
+	for (let i = 0; i < maxMinutes; i++) {
+		if (matchesCron(schedule, candidate, timezone)) return candidate;
+		candidate.setTime(candidate.getTime() + 6e4);
+	}
+	return null;
+}
+/** Returns true if the given Date matches the cron schedule in the specified timezone. */
+function matchesCron(schedule, date, timezone) {
+	const tz = timezone || "UTC";
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: tz,
+		hour: "numeric",
+		minute: "numeric",
+		day: "numeric",
+		month: "numeric",
+		weekday: "short",
+		hour12: false
+	}).formatToParts(date);
+	const get = (type) => Number(parts.find((p) => p.type === type)?.value ?? 0);
+	const weekdayStr = parts.find((p) => p.type === "weekday")?.value ?? "";
+	return schedule.minutes.has(get("minute")) && schedule.hours.has(get("hour")) && schedule.daysOfMonth.has(get("day")) && schedule.months.has(get("month")) && schedule.daysOfWeek.has({
+		Sun: 0,
+		Mon: 1,
+		Tue: 2,
+		Wed: 3,
+		Thu: 4,
+		Fri: 5,
+		Sat: 6
+	}[weekdayStr] ?? 0);
+}
+
+//#endregion
+//#region src/server/routes.ts
+function buildStatusPayload(getConfig, startedAt, getDeps) {
+	const config = getConfig();
+	const deps = getDeps();
+	const jobs = getJobStats();
+	const flights = getFlightStats();
+	const messages = getMessageStats();
+	const health = deps.serviceHealth();
+	return {
+		uptime: Date.now() - startedAt,
+		processes: {
+			active: deps.activeProcessCount(),
+			maxConcurrent: config.sessions.maxConcurrent
+		},
+		jobs,
+		flights,
+		messages,
+		sessions: { total: getSessionCount() },
+		web: {
+			enabled: config.web.enabled,
+			port: config.web.port
+		},
+		agent: health.agent,
+		browser: {
+			enabled: config.browser.enabled,
+			connected: health.browser.connected
+		},
+		slack: { connected: deps.slackConnected() }
+	};
+}
+function resolveBirdParam(params, res) {
+	const uid = params["id"];
+	if (!uid) {
+		jsonError(res, "Missing bird ID", 400);
+		return null;
+	}
+	const result = resolveByUid("cron_jobs", uid);
+	if (!result) {
+		jsonError(res, `Bird ${uid} not found`, 404);
+		return null;
+	}
+	if ("ambiguous" in result) {
+		jsonError(res, `Ambiguous bird ID "${uid}" matches ${result.count} birds. Use a longer prefix.`, 400);
+		return null;
+	}
+	return result.row;
+}
+const VALID_PROVIDERS = new Set(["claude", "opencode"]);
+function maskSecret(value) {
+	if (!value) return {
+		set: false,
+		hint: ""
+	};
+	const prefix = [
+		"xoxb-",
+		"xapp-",
+		"sk-ant-api",
+		"sk-ant-oat"
+	].find((p) => value.startsWith(p)) ?? "";
+	const tail = value.length > 4 ? value.slice(-4) : "";
+	return {
+		set: true,
+		hint: prefix ? `${prefix}...${tail}` : `...${tail}`
+	};
+}
+const HH_MM_RE = /^\d{2}:\d{2}$/;
+const ALLOWED_TOP_LEVEL_KEYS = new Set([
+	"timezone",
+	"agents",
+	"sessions",
+	"slack",
+	"birds",
+	"browser",
+	"database"
+]);
+function sanitizeConfig(config) {
+	return {
+		timezone: config.timezone,
+		agents: config.agents.map((a) => ({
+			id: a.id,
+			name: a.name,
+			provider: a.provider,
+			model: a.model,
+			fallbackModel: a.fallbackModel ?? null,
+			maxTurns: a.maxTurns,
+			systemPrompt: a.systemPrompt,
+			channels: a.channels
+		})),
+		sessions: {
+			ttlHours: config.sessions.ttlHours,
+			maxConcurrent: config.sessions.maxConcurrent,
+			processTimeoutMs: config.sessions.processTimeoutMs
+		},
+		slack: {
+			requireMention: config.slack.requireMention,
+			coalesce: config.slack.coalesce,
+			channels: config.slack.channels,
+			quietHours: config.slack.quietHours
+		},
+		birds: config.birds,
+		browser: {
+			enabled: config.browser.enabled,
+			mode: process.env["BROWSER_MODE"] ?? "persistent",
+			novncHost: config.browser.novncHost,
+			vncPort: config.browser.vncPort,
+			novncPort: config.browser.novncPort
+		},
+		database: config.database,
+		web: { port: config.web.port }
+	};
+}
+function validateConfigPatch(body) {
+	for (const key of Object.keys(body)) if (!ALLOWED_TOP_LEVEL_KEYS.has(key)) return `Unknown config key "${key}"`;
+	if ("timezone" in body && typeof body["timezone"] !== "string") return "\"timezone\" must be a string";
+	if ("agents" in body) {
+		const agents = body["agents"];
+		if (!Array.isArray(agents) || agents.length === 0) return "\"agents\" must be a non-empty array";
+		for (const a of agents) {
+			if (!a["id"] || typeof a["id"] !== "string") return "Each agent must have a string \"id\"";
+			if (!a["name"] || typeof a["name"] !== "string") return "Each agent must have a string \"name\"";
+			if (!a["provider"] || !VALID_PROVIDERS.has(a["provider"])) return `Agent "${a["id"]}": invalid provider (expected: ${[...VALID_PROVIDERS].join(", ")})`;
+			if (!a["model"] || typeof a["model"] !== "string") return `Agent "${a["id"]}": "model" is required`;
+			if (!Array.isArray(a["channels"]) || a["channels"].length === 0) return `Agent "${a["id"]}": "channels" must be a non-empty array`;
+		}
+	}
+	if ("sessions" in body) {
+		const s = body["sessions"];
+		if (typeof s !== "object" || s == null) return "\"sessions\" must be an object";
+		for (const k of [
+			"ttlHours",
+			"maxConcurrent",
+			"processTimeoutMs"
+		]) if (k in s && (typeof s[k] !== "number" || s[k] <= 0)) return `"sessions.${k}" must be a positive number`;
+	}
+	if ("slack" in body) {
+		const sl = body["slack"];
+		if (typeof sl !== "object" || sl == null) return "\"slack\" must be an object";
+		if ("requireMention" in sl && typeof sl["requireMention"] !== "boolean") return "\"slack.requireMention\" must be a boolean";
+		if ("channels" in sl) {
+			if (!Array.isArray(sl["channels"])) return "\"slack.channels\" must be an array";
+		}
+		if ("coalesce" in sl) {
+			const c = sl["coalesce"];
+			if (typeof c !== "object" || c == null) return "\"slack.coalesce\" must be an object";
+			if ("debounceMs" in c && (typeof c["debounceMs"] !== "number" || c["debounceMs"] <= 0)) return "\"slack.coalesce.debounceMs\" must be a positive number";
+			if ("bypassDms" in c && typeof c["bypassDms"] !== "boolean") return "\"slack.coalesce.bypassDms\" must be a boolean";
+		}
+		if ("quietHours" in sl) {
+			const q = sl["quietHours"];
+			if (typeof q !== "object" || q == null) return "\"slack.quietHours\" must be an object";
+			if ("enabled" in q && typeof q["enabled"] !== "boolean") return "\"slack.quietHours.enabled\" must be a boolean";
+			if ("start" in q && (typeof q["start"] !== "string" || !HH_MM_RE.test(q["start"]))) return "\"slack.quietHours.start\" must be HH:MM format";
+			if ("end" in q && (typeof q["end"] !== "string" || !HH_MM_RE.test(q["end"]))) return "\"slack.quietHours.end\" must be HH:MM format";
+		}
+	}
+	if ("birds" in body) {
+		const b = body["birds"];
+		if (typeof b !== "object" || b == null) return "\"birds\" must be an object";
+		if ("maxAttempts" in b && (!Number.isInteger(b["maxAttempts"]) || b["maxAttempts"] <= 0)) return "\"birds.maxAttempts\" must be a positive integer";
+	}
+	if ("browser" in body) {
+		const br = body["browser"];
+		if (typeof br !== "object" || br == null) return "\"browser\" must be an object";
+		if ("enabled" in br && typeof br["enabled"] !== "boolean") return "\"browser.enabled\" must be a boolean";
+		if ("novncHost" in br && (typeof br["novncHost"] !== "string" || !br["novncHost"].trim())) return "\"browser.novncHost\" must be a non-empty string";
+	}
+	if ("database" in body) {
+		const d = body["database"];
+		if (typeof d !== "object" || d == null) return "\"database\" must be an object";
+		if ("retentionDays" in d && (!Number.isInteger(d["retentionDays"]) || d["retentionDays"] <= 0)) return "\"database.retentionDays\" must be a positive integer";
+	}
+	return null;
+}
+function buildRoutes(getConfig, startedAt, getDeps, options) {
+	return [
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/auth/check"),
+			skipAuth: true,
+			handler(_req, res) {
+				const count = getUserCount();
+				json(res, {
+					setupRequired: count === 0,
+					authRequired: count > 0,
+					onboardingRequired: count > 0 && getSetting("onboarding_completed") !== "true"
+				});
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/auth/setup"),
+			skipAuth: true,
+			async handler(req, res) {
+				if (getUserCount() > 0) {
+					jsonError(res, "Setup already completed", 403);
+					return;
+				}
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				if (!body.email || typeof body.email !== "string" || !body.email.trim()) {
+					jsonError(res, "\"email\" is required", 400);
+					return;
+				}
+				if (!body.password || typeof body.password !== "string" || body.password.length < 8) {
+					jsonError(res, "Password must be at least 8 characters", 400);
+					return;
+				}
+				const email = body.email.trim().toLowerCase();
+				const passwordHash = await hashPassword(body.password);
+				const tokenKey = generateTokenKey();
+				const user = createUser(email, passwordHash, tokenKey);
+				const secret = getOrCreateSecret();
+				json(res, {
+					token: signToken(user.id, tokenKey, secret),
+					user: {
+						id: user.id,
+						email: user.email
+					}
+				}, 201);
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/auth/login"),
+			skipAuth: true,
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				if (!body.email || !body.password) {
+					jsonError(res, "Invalid credentials", 401);
+					return;
+				}
+				const user = getUserByEmail(body.email.trim());
+				if (!user) {
+					jsonError(res, "Invalid credentials", 401);
+					return;
+				}
+				if (!await verifyPassword(body.password, user.password_hash)) {
+					jsonError(res, "Invalid credentials", 401);
+					return;
+				}
+				const secret = getOrCreateSecret();
+				json(res, {
+					token: signToken(user.id, user.token_key, secret),
+					user: {
+						id: user.id,
+						email: user.email
+					}
+				});
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/auth/verify"),
+			handler(_req, res) {
+				json(res, { valid: true });
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/doctor"),
+			handler(_req, res) {
+				json(res, checkDoctor());
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/status"),
+			handler(_req, res) {
+				json(res, buildStatusPayload(getConfig, startedAt, getDeps));
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/config"),
+			handler(_req, res) {
+				json(res, sanitizeConfig(getConfig()));
+			}
+		},
+		{
+			method: "PATCH",
+			pattern: pathToRegex("/api/config"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				const error = validateConfigPatch(body);
+				if (error) {
+					jsonError(res, error, 400);
+					return;
+				}
+				try {
+					const merged = deepMerge(loadRawConfig(options.configPath), body);
+					saveConfig(options.configPath, merged);
+					options.onConfigReload();
+					broadcastSSE("invalidate", { resource: "config" });
+					json(res, sanitizeConfig(getConfig()));
+				} catch (err) {
+					jsonError(res, `Failed to save config: ${err instanceof Error ? err.message : String(err)}`, 500);
+				}
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/secrets"),
+			handler(_req, res) {
+				const activeAnthropicValue = process.env["CLAUDE_CODE_OAUTH_TOKEN"] || process.env["ANTHROPIC_API_KEY"];
+				json(res, {
+					slack: {
+						botToken: maskSecret(process.env["SLACK_BOT_TOKEN"]),
+						appToken: maskSecret(process.env["SLACK_APP_TOKEN"])
+					},
+					anthropic: maskSecret(activeAnthropicValue)
+				});
+			}
+		},
+		{
+			method: "PUT",
+			pattern: pathToRegex("/api/secrets/slack"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				const botToken = body.botToken?.trim();
+				const appToken = body.appToken?.trim();
+				if (!botToken && !appToken) {
+					jsonError(res, "Provide \"botToken\" and/or \"appToken\"", 400);
+					return;
+				}
+				const { WebClient } = await import("@slack/web-api");
+				const envVars = {};
+				if (botToken) {
+					if (!botToken.startsWith("xoxb-")) {
+						jsonError(res, "Bot token must start with xoxb-", 400);
+						return;
+					}
+					try {
+						await new WebClient(botToken).auth.test();
+					} catch {
+						jsonError(res, "Invalid bot token. Check that you copied the full xoxb- token.", 400);
+						return;
+					}
+					envVars["SLACK_BOT_TOKEN"] = botToken;
+				}
+				if (appToken) {
+					if (!appToken.startsWith("xapp-")) {
+						jsonError(res, "App token must start with xapp-", 400);
+						return;
+					}
+					try {
+						await new WebClient(appToken).apiCall("apps.connections.open");
+					} catch {
+						jsonError(res, "Invalid app token. Check that you created an app-level token with the connections:write scope.", 400);
+						return;
+					}
+					envVars["SLACK_APP_TOKEN"] = appToken;
+				}
+				try {
+					const envPath = resolve(".env");
+					saveEnvFile(envPath, envVars);
+					loadDotEnv(envPath);
+					options.onConfigReload();
+					broadcastSSE("invalidate", { resource: "secrets" });
+					json(res, {
+						success: true,
+						requiresRestart: true
+					});
+				} catch (err) {
+					jsonError(res, `Failed to save Slack tokens: ${err instanceof Error ? err.message : String(err)}`, 500);
+				}
+			}
+		},
+		{
+			method: "PUT",
+			pattern: pathToRegex("/api/secrets/anthropic"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				if (!body.apiKey || typeof body.apiKey !== "string" || !body.apiKey.trim()) {
+					jsonError(res, "\"apiKey\" is required", 400);
+					return;
+				}
+				const key = body.apiKey.trim();
+				let envVar;
+				if (key.startsWith("sk-ant-oat")) envVar = "CLAUDE_CODE_OAUTH_TOKEN";
+				else if (key.startsWith("sk-ant-api")) envVar = "ANTHROPIC_API_KEY";
+				else {
+					jsonError(res, "Invalid key. Expected an Anthropic key starting with sk-ant-...", 400);
+					return;
+				}
+				try {
+					const envPath = resolve(".env");
+					saveEnvFile(envPath, { [envVar]: key });
+					loadDotEnv(envPath);
+					options.onConfigReload();
+					broadcastSSE("invalidate", { resource: "secrets" });
+					json(res, {
+						success: true,
+						requiresRestart: false
+					});
+				} catch (err) {
+					jsonError(res, `Failed to save Anthropic key: ${err instanceof Error ? err.message : String(err)}`, 500);
+				}
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/sessions"),
+			handler(req, res) {
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const { page, perPage } = parsePagination(url);
+				json(res, listSessions(page, perPage, parseSortParam(url), parseSearchParam(url)));
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/sessions/:id"),
+			handler(req, res, params) {
+				const uid = params["id"];
+				if (!uid) {
+					jsonError(res, "Missing session ID", 400);
+					return;
+				}
+				const session = getSession(uid);
+				if (!session) {
+					jsonError(res, `Session ${uid} not found`, 404);
+					return;
+				}
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const { page, perPage } = parsePagination(url);
+				json(res, {
+					session,
+					messages: getSessionMessages(session.channel_id, session.thread_id, page, perPage, parseSortParam(url), parseSearchParam(url)),
+					stats: getSessionTokenStats(session.channel_id, session.thread_id)
+				});
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/jobs/stats"),
+			handler(_req, res) {
+				json(res, getJobStats());
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/jobs/retry-all"),
+			handler(_req, res) {
+				json(res, { count: retryAllFailedJobs() });
+			}
+		},
+		{
+			method: "DELETE",
+			pattern: pathToRegex("/api/jobs/clear"),
+			handler(req, res) {
+				const status = new URL(req.url ?? "/", `http://${req.headers.host}`).searchParams.get("status");
+				if (status !== "completed" && status !== "failed") {
+					jsonError(res, "Query param \"status\" must be \"completed\" or \"failed\"", 400);
+					return;
+				}
+				json(res, { count: clearJobs(status) });
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/jobs"),
+			handler(req, res) {
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const { page, perPage } = parsePagination(url);
+				json(res, listJobs(page, perPage, {
+					status: url.searchParams.get("status") ?? void 0,
+					cronJobUid: url.searchParams.get("cronJobUid") ?? void 0,
+					name: url.searchParams.get("name") ?? void 0
+				}, parseSortParam(url), parseSearchParam(url)));
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/jobs/:id/retry"),
+			handler(_req, res, params) {
+				const id = Number(params["id"]);
+				if (!Number.isFinite(id)) {
+					jsonError(res, "Invalid job ID", 400);
+					return;
+				}
+				if (retryJob(id)) json(res, { success: true });
+				else jsonError(res, `Job #${id} not found or not in failed state`, 404);
+			}
+		},
+		{
+			method: "DELETE",
+			pattern: pathToRegex("/api/jobs/:id"),
+			handler(_req, res, params) {
+				const id = Number(params["id"]);
+				if (!Number.isFinite(id)) {
+					jsonError(res, "Invalid job ID", 400);
+					return;
+				}
+				if (deleteJob(id)) json(res, { success: true });
+				else jsonError(res, `Job #${id} not found`, 404);
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/birds/upcoming"),
+			handler(req, res) {
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const limit = Math.min(Math.max(Number(url.searchParams.get("limit")) || 5, 1), 20);
+				const now = /* @__PURE__ */ new Date();
+				const upcoming = [];
+				for (const bird of getEnabledCronJobs()) {
+					if (bird.name.startsWith(SYSTEM_CRON_PREFIX)) continue;
+					try {
+						const next = nextCronMatch(parseCron(bird.schedule), now, bird.timezone);
+						if (next) upcoming.push({
+							uid: bird.uid,
+							name: bird.name,
+							schedule: bird.schedule,
+							agent_id: bird.agent_id,
+							next_run: next.toISOString()
+						});
+					} catch {}
+				}
+				upcoming.sort((a, b) => a.next_run.localeCompare(b.next_run));
+				json(res, upcoming.slice(0, limit));
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/birds"),
+			handler(req, res) {
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const { page, perPage } = parsePagination(url);
+				json(res, listCronJobs(page, perPage, parseSystemFlag(url), parseSortParam(url), parseSearchParam(url)));
+			}
+		},
+		{
+			method: "PATCH",
+			pattern: pathToRegex("/api/birds/:id/enable"),
+			handler(_req, res, params) {
+				const bird = resolveBirdParam(params, res);
+				if (!bird) return;
+				setCronJobEnabled(bird.uid, true);
+				broadcastSSE("invalidate", { resource: "birds" });
+				json(res, { success: true });
+			}
+		},
+		{
+			method: "PATCH",
+			pattern: pathToRegex("/api/birds/:id/disable"),
+			handler(_req, res, params) {
+				const bird = resolveBirdParam(params, res);
+				if (!bird) return;
+				setCronJobEnabled(bird.uid, false);
+				broadcastSSE("invalidate", { resource: "birds" });
+				json(res, { success: true });
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/birds"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				if (!body.schedule || typeof body.schedule !== "string" || !body.schedule.trim()) {
+					jsonError(res, "\"schedule\" is required", 400);
+					return;
+				}
+				if (!body.prompt || typeof body.prompt !== "string" || !body.prompt.trim()) {
+					jsonError(res, "\"prompt\" is required", 400);
+					return;
+				}
+				const job = createCronJob(deriveBirdName(body.prompt), body.schedule.trim(), body.prompt.trim(), body.channel?.trim() || void 0, body.agent?.trim() || void 0, body.timezone?.trim() || getConfig().timezone, body.activeHoursStart?.trim() || void 0, body.activeHoursEnd?.trim() || void 0);
+				broadcastSSE("invalidate", { resource: "birds" });
+				json(res, job, 201);
+			}
+		},
+		{
+			method: "PATCH",
+			pattern: pathToRegex("/api/birds/:id"),
+			async handler(req, res, params) {
+				const bird = resolveBirdParam(params, res);
+				if (!bird) return;
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				const updated = updateCronJob(bird.uid, {
+					schedule: body.schedule?.trim() || void 0,
+					prompt: body.prompt?.trim() || void 0,
+					name: body.prompt ? deriveBirdName(body.prompt) : void 0,
+					targetChannelId: body.channel !== void 0 ? body.channel?.trim() || null : void 0,
+					agentId: body.agent?.trim() || void 0,
+					timezone: body.timezone?.trim() || void 0,
+					activeHoursStart: body.activeHoursStart !== void 0 ? body.activeHoursStart?.trim() || null : void 0,
+					activeHoursEnd: body.activeHoursEnd !== void 0 ? body.activeHoursEnd?.trim() || null : void 0
+				});
+				if (updated) {
+					broadcastSSE("invalidate", { resource: "birds" });
+					json(res, updated);
+				} else jsonError(res, `Bird ${bird.uid} not found`, 404);
+			}
+		},
+		{
+			method: "DELETE",
+			pattern: pathToRegex("/api/birds/:id"),
+			handler(_req, res, params) {
+				const bird = resolveBirdParam(params, res);
+				if (!bird) return;
+				if (bird.name.startsWith(SYSTEM_CRON_PREFIX)) {
+					jsonError(res, "System birds cannot be deleted", 403);
+					return;
+				}
+				deleteCronJob(bird.uid);
+				broadcastSSE("invalidate", { resource: "birds" });
+				json(res, { success: true });
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/birds/:id/fly"),
+			handler(_req, res, params) {
+				const bird = resolveBirdParam(params, res);
+				if (!bird) return;
+				json(res, {
+					success: true,
+					jobId: (bird.name.startsWith(SYSTEM_CRON_PREFIX) ? enqueue("system_cron_run", {
+						cronJobUid: bird.uid,
+						cronName: bird.name
+					}, {
+						maxAttempts: 3,
+						timeout: 300,
+						cronJobUid: bird.uid
+					}) : enqueue("cron_run", {
+						cronJobUid: bird.uid,
+						prompt: bird.prompt,
+						channelId: bird.target_channel_id,
+						agentId: bird.agent_id
+					}, { cronJobUid: bird.uid })).id
+				});
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/flights"),
+			handler(req, res) {
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const { page, perPage } = parsePagination(url);
+				json(res, listFlights(page, perPage, {
+					status: url.searchParams.get("status") ?? void 0,
+					birdUid: url.searchParams.get("birdUid") ?? void 0,
+					system: parseSystemFlag(url)
+				}, parseSortParam(url), parseSearchParam(url)));
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/birds/:id/flights"),
+			handler(req, res, params) {
+				const bird = resolveBirdParam(params, res);
+				if (!bird) return;
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const { page, perPage } = parsePagination(url);
+				json(res, listFlights(page, perPage, {
+					birdUid: bird.uid,
+					system: true
+				}, parseSortParam(url), parseSearchParam(url)));
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/messages/stats"),
+			handler(_req, res) {
+				json(res, getMessageStats());
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/logs"),
+			handler(req, res) {
+				const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+				const { page, perPage } = parsePagination(url);
+				json(res, getRecentLogs(page, perPage, url.searchParams.get("level") ?? void 0, url.searchParams.get("source") ?? void 0, parseSortParam(url), parseSearchParam(url)));
+			}
+		},
+		{
+			method: "GET",
+			pattern: pathToRegex("/api/onboarding/defaults"),
+			handler(_req, res) {
+				const doctor = checkDoctor();
+				const defaultAgent = DEFAULTS.agents[0];
+				json(res, {
+					agent: {
+						name: defaultAgent.name,
+						provider: defaultAgent.provider,
+						model: defaultAgent.model,
+						systemPrompt: defaultAgent.systemPrompt,
+						maxTurns: defaultAgent.maxTurns,
+						channels: defaultAgent.channels
+					},
+					browser: {
+						enabled: DEFAULTS.browser.enabled,
+						novncHost: DEFAULTS.browser.novncHost,
+						novncPort: DEFAULTS.browser.novncPort
+					},
+					doctor
+				});
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/onboarding/slack"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				if (!body.botToken || typeof body.botToken !== "string" || !body.botToken.trim()) {
+					jsonError(res, "\"botToken\" is required", 400);
+					return;
+				}
+				if (!body.appToken || typeof body.appToken !== "string" || !body.appToken.trim()) {
+					jsonError(res, "\"appToken\" is required", 400);
+					return;
+				}
+				const botToken = body.botToken.trim();
+				const appToken = body.appToken.trim();
+				if (!botToken.startsWith("xoxb-")) {
+					jsonError(res, "Bot token must start with xoxb-", 400);
+					return;
+				}
+				if (!appToken.startsWith("xapp-")) {
+					jsonError(res, "App token must start with xapp-", 400);
+					return;
+				}
+				const { WebClient } = await import("@slack/web-api");
+				let authResult;
+				try {
+					authResult = await new WebClient(botToken).auth.test();
+				} catch {
+					jsonError(res, "Invalid bot token. Check that you copied the full xoxb- token.", 400);
+					return;
+				}
+				try {
+					await new WebClient(appToken).apiCall("apps.connections.open");
+				} catch {
+					jsonError(res, "Invalid app token. Check that you created an app-level token with the connections:write scope.", 400);
+					return;
+				}
+				try {
+					saveEnvFile(resolve(".env"), {
+						SLACK_BOT_TOKEN: botToken,
+						SLACK_APP_TOKEN: appToken
+					});
+					const configPath = options.configPath;
+					const raw = loadRawConfig(configPath);
+					const slack = raw["slack"] ?? {};
+					slack["botToken"] = "env:SLACK_BOT_TOKEN";
+					slack["appToken"] = "env:SLACK_APP_TOKEN";
+					raw["slack"] = slack;
+					saveConfig(configPath, raw);
+					json(res, {
+						valid: true,
+						team: authResult.team ?? "",
+						botUser: authResult.user ?? ""
+					});
+				} catch (err) {
+					jsonError(res, `Failed to save Slack config: ${err instanceof Error ? err.message : String(err)}`, 500);
+				}
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/onboarding/agent"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				if (!body.name || typeof body.name !== "string") {
+					jsonError(res, "\"name\" is required", 400);
+					return;
+				}
+				if (!body.provider || typeof body.provider !== "string") {
+					jsonError(res, "\"provider\" is required", 400);
+					return;
+				}
+				if (!body.model || typeof body.model !== "string") {
+					jsonError(res, "\"model\" is required", 400);
+					return;
+				}
+				const configPath = options.configPath;
+				const raw = loadRawConfig(configPath);
+				raw["agents"] = [{
+					id: "default",
+					name: body.name.trim(),
+					provider: body.provider.trim(),
+					model: body.model.trim(),
+					maxTurns: body.maxTurns ?? DEFAULTS.agents[0].maxTurns,
+					systemPrompt: body.systemPrompt?.trim() ?? DEFAULTS.agents[0].systemPrompt,
+					channels: body.channels ?? ["*"]
+				}];
+				saveConfig(configPath, raw);
+				json(res, { agents: raw["agents"] });
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/onboarding/auth"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				if (!body.apiKey || typeof body.apiKey !== "string" || !body.apiKey.trim()) {
+					jsonError(res, "\"apiKey\" is required", 400);
+					return;
+				}
+				const key = body.apiKey.trim();
+				let envVar;
+				if (key.startsWith("sk-ant-oat")) envVar = "CLAUDE_CODE_OAUTH_TOKEN";
+				else if (key.startsWith("sk-ant-api")) envVar = "ANTHROPIC_API_KEY";
+				else {
+					jsonError(res, "Invalid key. Expected an Anthropic key starting with sk-ant-...", 400);
+					return;
+				}
+				saveEnvFile(resolve(".env"), { [envVar]: key });
+				json(res, { valid: true });
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/onboarding/browser/probe"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				const host = body.host?.trim();
+				if (!host) {
+					jsonError(res, "\"host\" is required", 400);
+					return;
+				}
+				json(res, { reachable: await probeBrowser(host, body.port ?? DEFAULTS.browser.novncPort) });
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/onboarding/browser"),
+			async handler(req, res) {
+				let body;
+				try {
+					body = await readJsonBody(req);
+				} catch {
+					jsonError(res, "Invalid JSON body", 400);
+					return;
+				}
+				const configPath = options.configPath;
+				const raw = loadRawConfig(configPath);
+				const browser = raw["browser"] ?? {};
+				if (body.enabled !== void 0) browser["enabled"] = body.enabled;
+				if (body.novncHost !== void 0) browser["novncHost"] = body.novncHost.trim();
+				raw["browser"] = browser;
+				saveConfig(configPath, raw);
+				json(res, { browser: raw["browser"] });
+			}
+		},
+		{
+			method: "POST",
+			pattern: pathToRegex("/api/onboarding/complete"),
+			async handler(_req, res) {
+				try {
+					await options.onLaunch();
+					setSetting("onboarding_completed", "true");
+					json(res, { success: true });
+				} catch (err) {
+					jsonError(res, `Launch failed: ${err instanceof Error ? err.message : String(err)}`, 500);
+				}
+			}
+		}
+	];
+}
+
+//#endregion
+//#region src/server/sse.ts
+const sseConnections = /* @__PURE__ */ new Set();
+function handleSSE(getConfig, startedAt, getDeps, req, res) {
+	if (!checkAuth(req, res, true)) return;
+	res.writeHead(200, {
+		"Content-Type": "text/event-stream; charset=utf-8",
+		"Cache-Control": "no-cache, no-transform",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no"
+	});
+	sseConnections.add(res);
+	const send = () => {
+		const data = JSON.stringify(buildStatusPayload(getConfig, startedAt, getDeps));
+		res.write(`event: status\ndata: ${data}\n\n`);
+	};
+	send();
+	const timer = setInterval(send, 5e3);
+	req.on("close", () => {
+		clearInterval(timer);
+		sseConnections.delete(res);
+	});
+}
+function broadcastSSE(event, data) {
+	const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+	for (const res of sseConnections) if (!res.destroyed) res.write(payload);
+}
+function closeAllSSE() {
+	for (const res of sseConnections) res.end();
+	sseConnections.clear();
+}
+
+//#endregion
+//#region src/server/static.ts
+const WEB_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "web", "dist");
+function serveStatic(res, urlPath) {
+	if (!existsSync(WEB_DIR)) {
+		res.writeHead(503, { "Content-Type": "text/plain" });
+		res.end("Web UI not built");
+		return;
+	}
+	if (urlPath === "/" || urlPath === "") urlPath = "/index.html";
+	const filePath = join(WEB_DIR, urlPath);
+	if (!filePath.startsWith(WEB_DIR)) {
+		res.writeHead(403);
+		res.end("Forbidden");
+		return;
+	}
+	try {
+		const content = readFileSync(filePath);
+		const contentType = MIME_TYPES[extname(filePath)] ?? "application/octet-stream";
+		res.writeHead(200, { "Content-Type": contentType });
+		res.end(content);
+	} catch {
+		try {
+			const indexContent = readFileSync(join(WEB_DIR, "index.html"));
+			res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+			res.end(indexContent);
+		} catch {
+			res.writeHead(404);
+			res.end("Not found");
+		}
+	}
+}
+
+//#endregion
+//#region src/server/vnc-proxy.ts
+/** @fileoverview WebSocket proxy for VNC: tunnels browser connections to upstream noVNC. */
+function destroyWithStatus(socket, status, message) {
+	const body = `HTTP/1.1 ${status} ${message}\r\n\r\n`;
+	socket.end(body);
+}
+function checkUpgradeAuth(req) {
+	if (getUserCount() === 0) return true;
+	const token = new URL(req.url ?? "/", `http://${req.headers.host}`).searchParams.get("token");
+	return token != null && verifyToken(token);
+}
+function handleVncUpgrade(getConfig, req, socket, head) {
+	const config = getConfig();
+	if (!config.browser.enabled) {
+		destroyWithStatus(socket, 404, "Not Found");
+		return;
+	}
+	if (!checkUpgradeAuth(req)) {
+		destroyWithStatus(socket, 403, "Forbidden");
+		return;
+	}
+	const { novncHost, novncPort } = config.browser;
+	logger.info(`vnc proxy connecting to ${novncHost}:${novncPort}`);
+	const upstream = connect(novncPort, novncHost, () => {
+		logger.info(`vnc proxy connected to ${novncHost}:${novncPort}`);
+		let rawHeaders = `GET /websockify HTTP/${req.httpVersion}\r\n`;
+		for (let i = 0; i < req.rawHeaders.length; i += 2) rawHeaders += `${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}\r\n`;
+		rawHeaders += "\r\n";
+		upstream.write(rawHeaders);
+		if (head.length > 0) upstream.write(head);
+		socket.pipe(upstream);
+		upstream.pipe(socket);
+	});
+	upstream.on("error", (err) => {
+		const code = err.code ?? "";
+		logger.error(`vnc proxy upstream error: ${code} ${err.message}`);
+		socket.destroy();
+	});
+	socket.on("error", (err) => {
+		const code = err.code ?? "";
+		logger.error(`vnc proxy client error: ${code} ${err.message}`);
+		upstream.destroy();
+	});
+	upstream.on("close", () => socket.destroy());
+	socket.on("close", () => upstream.destroy());
+}
+
+//#endregion
+//#region src/server/lifecycle.ts
+/** @fileoverview Web server lifecycle: creation, request routing, and shutdown. */
+function setCorsHeaders(getConfig, res) {
+	const origin = getConfig().web.corsOrigin;
+	if (!origin) return;
+	res.setHeader("Access-Control-Allow-Origin", origin);
+	res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+	res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
+	res.setHeader("Access-Control-Max-Age", "86400");
+}
+function createWebServer(getConfig, signal, getDeps, options) {
+	const startedAt = Date.now();
+	const routes = buildRoutes(getConfig, startedAt, getDeps, options);
+	let server = null;
+	const requestHandler = async (req, res) => {
+		const method = req.method ?? "GET";
+		const urlPath = req.url ?? "/";
+		const qIndex = urlPath.indexOf("?");
+		const pathOnly = qIndex !== -1 ? urlPath.slice(0, qIndex) : urlPath;
+		setCorsHeaders(getConfig, res);
+		if (method === "OPTIONS") {
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (method === "GET" && pathOnly === "/api/events") {
+			handleSSE(getConfig, startedAt, getDeps, req, res);
+			return;
+		}
+		for (const route of routes) {
+			if (route.method !== method) continue;
+			const match = pathOnly.match(route.pattern);
+			if (!match) continue;
+			if (!route.skipAuth && !checkAuth(req, res)) return;
+			const params = match.groups ?? {};
+			try {
+				await route.handler(req, res, params);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				logger.error(`api error: ${msg}`);
+				insertLog("error", "api", msg);
+				jsonError(res, "Internal server error", 500);
+			}
+			return;
+		}
+		if (method === "GET") {
+			serveStatic(res, pathOnly);
+			return;
+		}
+		jsonError(res, "Not found", 404);
+	};
+	return {
+		start() {
+			return new Promise((resolve, reject) => {
+				server = createServer((req, res) => {
+					requestHandler(req, res).catch((err) => {
+						logger.error(`unhandled request error: ${err instanceof Error ? err.message : String(err)}`);
+						if (!res.headersSent) jsonError(res, "Internal server error", 500);
+					});
+				});
+				server.on("upgrade", (req, socket, head) => {
+					const url = req.url ?? "/";
+					if ((url.indexOf("?") !== -1 ? url.slice(0, url.indexOf("?")) : url) === "/vnc") handleVncUpgrade(getConfig, req, socket, head);
+					else socket.destroy();
+				});
+				server.on("error", (err) => {
+					reject(err);
+				});
+				const config = getConfig();
+				server.listen(config.web.port, config.web.host, () => {
+					logger.info(`web server listening on http://${config.web.host}:${config.web.port}`);
+					resolve();
+				});
+				signal.addEventListener("abort", () => {
+					server?.close();
+				});
+			});
+		},
+		stop() {
+			return new Promise((resolve) => {
+				if (!server) {
+					resolve();
+					return;
+				}
+				closeAllSSE();
+				server.close(() => {
+					logger.info("web server stopped");
+					resolve();
+				});
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/jobs.ts
+const handlers = /* @__PURE__ */ new Map();
+const POLL_INTERVAL_MS = 1e3;
+const STALE_CHECK_INTERVAL_MS = 300 * 1e3;
+function registerHandler(name, handler) {
+	handlers.set(name, handler);
+}
+function enqueue(name, payload, options) {
+	const job = createJob({
+		name,
+		payload,
+		priority: options?.priority,
+		maxAttempts: options?.maxAttempts,
+		timeout: options?.timeout,
+		delaySeconds: options?.delaySeconds,
+		cronJobUid: options?.cronJobUid
+	});
+	logger.debug(`enqueued job ${job.id}: ${name}`);
+	return job;
+}
+async function processJob(job) {
+	const handler = handlers.get(job.name);
+	if (!handler) {
+		failJob(job.id, `no handler registered for "${job.name}"`);
+		logger.warn(`job ${job.id}: no handler for "${job.name}"`);
+		return;
+	}
+	const isCronRun = job.cron_job_uid != null;
+	const cronRun = isCronRun ? createCronRun(job.cron_job_uid) : null;
+	let finalStatus = "completed";
+	let resultText;
+	let errorText;
+	try {
+		const result = await handler(job.payload ? JSON.parse(job.payload) : void 0);
+		resultText = typeof result === "string" ? result : void 0;
+		completeJob(job.id, resultText);
+		logger.debug(`job ${job.id} completed: ${job.name}`);
+	} catch (err) {
+		finalStatus = "failed";
+		errorText = err instanceof Error ? err.message : String(err);
+		failJob(job.id, errorText);
+		logger.warn(`job ${job.id} failed (attempt ${job.attempts}/${job.max_attempts}): ${errorText}`);
+		insertLog("error", "cron", errorText);
+	} finally {
+		if (cronRun != null) completeCronRun(cronRun.uid, finalStatus === "completed" ? "success" : "error", resultText, errorText);
+		if (isCronRun && job.cron_job_uid != null) {
+			const cronJob = getCronJob(job.cron_job_uid);
+			if (cronJob != null) {
+				const newFailureCount = finalStatus === "failed" ? cronJob.failure_count + 1 : cronJob.failure_count;
+				updateCronJobStatus(job.cron_job_uid, finalStatus, newFailureCount);
+			}
+		}
+		const invalidatePayload = { resource: isCronRun ? "birds" : "sessions" };
+		if (job.cron_job_uid != null) invalidatePayload.cronJobUid = job.cron_job_uid;
+		broadcastSSE("invalidate", invalidatePayload);
+	}
+}
+/**
+* Starts the job worker loop. Polls for pending jobs, processes them one at a time.
+* Checks for stale running jobs every 5 minutes.
+*/
+function startWorker(signal) {
+	let pollTimer = null;
+	const pollTick = async () => {
+		if (signal.aborted) return;
+		const job = claimNextJob();
+		if (job) {
+			await processJob(job);
+			if (!signal.aborted) pollTick();
+			return;
+		}
+		pollTimer = setTimeout(pollTick, POLL_INTERVAL_MS);
+	};
+	const staleCheck = () => {
+		if (signal.aborted) return;
+		const stale = failStaleJobs();
+		if (stale > 0) logger.info(`timed out ${stale} stale job(s)`);
+	};
+	staleCheck();
+	const staleTimer = setInterval(staleCheck, STALE_CHECK_INTERVAL_MS);
+	signal.addEventListener("abort", () => {
+		if (pollTimer) clearTimeout(pollTimer);
+		clearInterval(staleTimer);
+	});
+	pollTick();
+}
+
+//#endregion
+//#region src/provider/session.ts
+/**
+* Matches an incoming message to the correct agent based on channel config.
+* Agents are checked in order; first match wins.
+* A wildcard `"*"` in the agent's channels array matches everything.
+*/
+function matchAgent(channelId, agents) {
+	for (const agent of agents) for (const pattern of agent.channels) if (pattern === "*" || pattern === channelId) return agent;
+}
+/**
+* Looks up or creates a session for the given Slack thread.
+* Returns the session row and whether it was newly created.
+*/
+function resolveSession(channelId, threadTs, config) {
+	const agent = matchAgent(channelId, config.agents);
+	if (!agent) {
+		logger.warn(`no agent matched for channel ${channelId}`);
+		return null;
+	}
+	const existing = findSession(channelId, threadTs);
+	if (existing) {
+		const ageHours = (Date.now() - (/* @__PURE__ */ new Date(existing.last_active + "Z")).getTime()) / (1e3 * 60 * 60);
+		if (ageHours > config.sessions.ttlHours) {
+			logger.info(`session ${existing.uid} expired (${ageHours.toFixed(1)}h old), starting fresh`);
+			return {
+				session: existing,
+				agent,
+				isNew: true
+			};
+		}
+		return {
+			session: existing,
+			agent,
+			isNew: false
+		};
+	}
+	const session = createSession(channelId, threadTs, agent.id, "");
+	logger.info(`created session ${session.uid} for channel=${channelId} thread=${threadTs ?? "none"} agent=${agent.id}`);
+	return {
+		session,
+		agent,
+		isNew: true
+	};
+}
+function expireStaleSessions(ttlHours) {
+	const deleted = deleteStaleSessions(ttlHours);
+	if (deleted > 0) logger.info(`expired ${deleted} stale session(s)`);
+	return deleted;
+}
+
+//#endregion
+//#region src/provider/stream.ts
+/**
+* Splits a raw data chunk into lines, handling partial lines across chunks.
+* Returns [completeLines, remainingPartial].
+*/
+function splitLines(buffer, chunk) {
+	const lines = (buffer + chunk).split("\n");
+	return [lines, lines.pop() ?? ""];
+}
+
+//#endregion
+//#region src/provider/claude.ts
+function buildCommand$1(options) {
+	const { message, sessionId, agent, mcpConfigPath } = options;
+	const args = [
+		"-p",
+		message,
+		"--output-format",
+		"stream-json",
+		"--model",
+		agent.model,
+		"--verbose",
+		"--max-turns",
+		String(agent.maxTurns)
+	];
+	if (sessionId) args.push("--resume", sessionId);
+	if (agent.systemPrompt) args.push("--append-system-prompt", agent.systemPrompt);
+	if (mcpConfigPath) args.push("--mcp-config", mcpConfigPath);
+	if (agent.fallbackModel) args.push("--fallback-model", agent.fallbackModel);
+	args.push("--dangerously-skip-permissions");
+	const oauthToken = process.env["CLAUDE_CODE_OAUTH_TOKEN"];
+	const apiKey = process.env["ANTHROPIC_API_KEY"];
+	return {
+		binary: "claude",
+		args,
+		env: oauthToken ? { CLAUDE_CODE_OAUTH_TOKEN: oauthToken } : apiKey ? { ANTHROPIC_API_KEY: apiKey } : {}
+	};
+}
+/**
+* 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.
+*/
+function parseStreamLine$1(line) {
+	const trimmed = line.trim();
+	if (!trimmed || !trimmed.startsWith("{")) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		return [];
+	}
+	const eventType = parsed["type"];
+	if (!eventType) return [];
+	switch (eventType) {
+		case "system":
+			if (typeof parsed["session_id"] === "string") return [{
+				type: "init",
+				sessionId: parsed["session_id"],
+				model: parsed["model"] ?? ""
+			}];
+			return [];
+		case "assistant": return parseAssistantContent(parsed);
+		case "user": return extractImages(parsed);
+		case "result": {
+			const usage = parsed["usage"];
+			return [{
+				type: "completion",
+				subtype: parsed["subtype"] ?? "success",
+				result: typeof parsed["result"] === "string" ? parsed["result"] : "",
+				sessionId: parsed["session_id"] ?? "",
+				isError: parsed["is_error"] ?? false,
+				tokensIn: usage?.["input_tokens"] ?? 0,
+				tokensOut: usage?.["output_tokens"] ?? 0,
+				cacheCreationTokens: usage?.["cache_creation_input_tokens"] ?? 0,
+				cacheReadTokens: usage?.["cache_read_input_tokens"] ?? 0,
+				costUsd: parsed["total_cost_usd"] ?? 0,
+				durationMs: parsed["duration_ms"] ?? 0,
+				numTurns: parsed["num_turns"] ?? 0
+			}];
+		}
+		case "rate_limit_event": {
+			const info = parsed["rate_limit_info"];
+			return [{
+				type: "rate_limit",
+				status: info?.["status"] ?? "unknown",
+				resetsAt: info?.["resetsAt"] ?? 0
+			}];
+		}
+		case "error": return [{
+			type: "error",
+			error: typeof parsed["error"] === "string" ? parsed["error"] : JSON.stringify(parsed["error"])
+		}];
+		default: return [];
+	}
+}
+function parseAssistantContent(parsed) {
+	const msg = parsed["message"];
+	if (typeof msg === "string") return [{
+		type: "text_delta",
+		delta: msg
+	}];
+	if (!msg || typeof msg !== "object") return [];
+	const content = msg["content"];
+	if (!Array.isArray(content)) return [];
+	const events = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const b = block;
+		if (b["type"] === "text" && typeof b["text"] === "string") events.push({
+			type: "text_delta",
+			delta: b["text"]
+		});
+	}
+	return events;
+}
+function extractImages(parsed) {
+	const msg = parsed["message"];
+	if (!msg || typeof msg !== "object") return [];
+	const content = msg["content"];
+	if (!Array.isArray(content)) return [];
+	const images = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const b = block;
+		if (b["type"] !== "tool_result") continue;
+		const inner = b["content"];
+		if (!Array.isArray(inner)) continue;
+		for (const item of inner) {
+			if (!item || typeof item !== "object") continue;
+			const i = item;
+			if (i["type"] !== "image") continue;
+			const source = i["source"];
+			if (!source || source["type"] !== "base64") continue;
+			images.push({
+				mediaType: source["media_type"] ?? "image/png",
+				data: source["data"] ?? ""
+			});
+		}
+	}
+	if (images.length > 0) return [{
+		type: "tool_images",
+		images
+	}];
+	return [];
+}
+const claude = {
+	buildCommand: buildCommand$1,
+	parseStreamLine: parseStreamLine$1
+};
+
+//#endregion
+//#region src/provider/opencode.ts
+/** @fileoverview OpenCode CLI provider: arg building, workspace setup, and JSON stream parsing. */
+const WORKSPACE_DIR = resolve(".browserbird", "opencode");
+/**
+* Translates a Claude-format MCP config into an opencode-format config.
+*
+* Claude format:  { mcpServers: { name: { type: "sse", url: "..." } } }
+* OpenCode format: { mcp: { name: { type: "remote", url: "..." } } }
+*/
+function translateMcpConfig(claudeConfig) {
+	const servers = claudeConfig["mcpServers"] ?? {};
+	const result = {};
+	for (const [name, server] of Object.entries(servers)) {
+		const serverType = server["type"];
+		const url = server["url"];
+		const command = server["command"];
+		const args = server["args"];
+		if (serverType === "sse" || serverType === "streamable-http") {
+			if (url) result[name] = {
+				type: "remote",
+				url
+			};
+		} else if (serverType === "stdio") {
+			if (command) {
+				const entry = {
+					type: "local",
+					command: args ? [command, ...args] : [command]
+				};
+				const env = server["env"];
+				if (env) entry["environment"] = env;
+				result[name] = entry;
+			}
+		}
+	}
+	return result;
+}
+/**
+* Ensures the opencode workspace directory exists with the right config files.
+* Writes opencode.json (MCP servers) and .opencode/agent/browserbird.md (system prompt).
+*/
+function ensureWorkspace(mcpConfigPath, systemPrompt) {
+	mkdirSync(resolve(WORKSPACE_DIR, ".opencode", "agent"), { recursive: true });
+	const config = {};
+	if (mcpConfigPath) try {
+		const raw = readFileSync(resolve(mcpConfigPath), "utf-8");
+		const mcp = translateMcpConfig(JSON.parse(raw));
+		if (Object.keys(mcp).length > 0) config["mcp"] = mcp;
+	} catch (err) {
+		logger.warn(`opencode: failed to read MCP config at ${mcpConfigPath}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	writeFileSync(resolve(WORKSPACE_DIR, "opencode.json"), JSON.stringify(config, null, 2) + "\n");
+	if (systemPrompt) {
+		const agentMd = `---\nmode: primary\n---\n\n${systemPrompt}\n`;
+		writeFileSync(resolve(WORKSPACE_DIR, ".opencode", "agent", "browserbird.md"), agentMd);
+	}
+	const agentsMd = resolve("AGENTS.md");
+	if (existsSync(agentsMd)) copyFileSync(agentsMd, resolve(WORKSPACE_DIR, "AGENTS.md"));
+}
+/**
+* Builds the `opencode run` command for a given agent config.
+*
+* @remarks `fallbackModel` is not yet supported by opencode.
+* @see https://github.com/anomalyco/opencode/issues/7602
+*/
+function buildCommand(options) {
+	const { message, sessionId, agent, mcpConfigPath } = options;
+	ensureWorkspace(mcpConfigPath, agent.systemPrompt);
+	const args = [
+		"run",
+		"--format",
+		"json",
+		"-m",
+		agent.model
+	];
+	if (agent.systemPrompt) args.push("--agent", "browserbird");
+	if (sessionId) args.push("--session", sessionId);
+	args.push(message);
+	const env = {};
+	const apiKey = process.env["ANTHROPIC_API_KEY"];
+	if (apiKey) env["ANTHROPIC_API_KEY"] = apiKey;
+	const openRouterKey = process.env["OPENROUTER_API_KEY"];
+	if (openRouterKey) env["OPENROUTER_API_KEY"] = openRouterKey;
+	const openAiKey = process.env["OPENAI_API_KEY"];
+	if (openAiKey) env["OPENAI_API_KEY"] = openAiKey;
+	const geminiKey = process.env["GEMINI_API_KEY"];
+	if (geminiKey) env["GEMINI_API_KEY"] = geminiKey;
+	return {
+		binary: "opencode",
+		args,
+		cwd: WORKSPACE_DIR,
+		env
+	};
+}
+/** Per-session metric accumulators. Concurrent sessions each get their own entry. */
+const accumulators = /* @__PURE__ */ new Map();
+function accumulateStep(sessionId, part) {
+	const acc = accumulators.get(sessionId);
+	acc.stepCount++;
+	const tokens = part["tokens"];
+	const cache = tokens?.["cache"];
+	acc.tokensIn += tokens?.["input"] ?? 0;
+	acc.tokensOut += tokens?.["output"] ?? 0;
+	acc.cacheWrite += cache?.["write"] ?? 0;
+	acc.cacheRead += cache?.["read"] ?? 0;
+	acc.cost += part["cost"] ?? 0;
+}
+/**
+* Parses a single line of opencode JSON output into zero or more StreamEvents.
+*
+* OpenCode emits these event types:
+*   step_start  -> init (first one carries sessionID)
+*   text        -> text_delta
+*   tool_use    -> ignored (internal to the agent)
+*   step_finish -> accumulates tokens/cost; final one (reason "stop") emits completion
+*   error       -> error (connection/auth failures)
+*/
+function parseStreamLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed || !trimmed.startsWith("{")) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		return [];
+	}
+	const eventType = parsed["type"];
+	if (!eventType) return [];
+	const part = parsed["part"];
+	const timestamp = parsed["timestamp"] ?? 0;
+	switch (eventType) {
+		case "step_start":
+			if (part && typeof part["sessionID"] === "string") {
+				const sid = part["sessionID"];
+				if (!accumulators.has(sid)) accumulators.set(sid, {
+					startTimestamp: timestamp,
+					stepCount: 0,
+					tokensIn: 0,
+					tokensOut: 0,
+					cacheWrite: 0,
+					cacheRead: 0,
+					cost: 0
+				});
+				return [{
+					type: "init",
+					sessionId: sid,
+					model: ""
+				}];
+			}
+			return [];
+		case "text":
+			if (part && typeof part["text"] === "string") return [{
+				type: "text_delta",
+				delta: part["text"]
+			}];
+			return [];
+		case "step_finish": {
+			if (!part) return [];
+			const sid = part["sessionID"] ?? "";
+			accumulateStep(sid, part);
+			if (part["reason"] !== "stop") return [];
+			const acc = accumulators.get(sid);
+			const durationMs = timestamp > acc.startTimestamp ? timestamp - acc.startTimestamp : 0;
+			const completion = {
+				type: "completion",
+				subtype: "success",
+				result: "",
+				sessionId: sid,
+				isError: false,
+				tokensIn: acc.tokensIn,
+				tokensOut: acc.tokensOut,
+				cacheCreationTokens: acc.cacheWrite,
+				cacheReadTokens: acc.cacheRead,
+				costUsd: acc.cost,
+				durationMs,
+				numTurns: acc.stepCount
+			};
+			accumulators.delete(sid);
+			return [completion];
+		}
+		case "error": {
+			const err = parsed["error"];
+			const data = err?.["data"];
+			return [{
+				type: "error",
+				error: typeof data?.["message"] === "string" && data["message"] || typeof parsed["message"] === "string" && parsed["message"] || typeof err?.["name"] === "string" && err["name"] || JSON.stringify(parsed)
+			}];
+		}
+		default: return [];
+	}
+}
+const opencode = {
+	buildCommand,
+	parseStreamLine
+};
+
+//#endregion
+//#region src/provider/spawn.ts
+/** @fileoverview Spawn a CLI provider as a subprocess. */
+const SIGKILL_GRACE_MS = 5e3;
+const PROVIDERS = {
+	claude,
+	opencode
+};
+/** Sends SIGTERM, then SIGKILL after a grace period if the process is still alive. */
+function gracefulKill(proc) {
+	if (!proc.pid || proc.killed) return;
+	proc.kill("SIGTERM");
+	const escalation = setTimeout(() => {
+		if (!proc.killed) {
+			logger.warn(`process ${proc.pid} did not exit after SIGTERM, sending SIGKILL`);
+			proc.kill("SIGKILL");
+		}
+	}, SIGKILL_GRACE_MS);
+	escalation.unref();
+	proc.on("exit", () => clearTimeout(escalation));
+}
+/** Env vars that prevent nested Claude Code sessions. */
+const STRIPPED_ENV_VARS = ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"];
+/** Strips env vars whose names suggest they hold credentials. */
+const SENSITIVE_NAME_RE$1 = /KEY|SECRET|TOKEN|PASSWORD/i;
+function cleanEnv() {
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (value == null) continue;
+		if (STRIPPED_ENV_VARS.includes(key)) continue;
+		if (SENSITIVE_NAME_RE$1.test(key)) continue;
+		env[key] = value;
+	}
+	return env;
+}
+/**
+* Spawns a provider CLI with streaming output.
+* Returns an async iterable of parsed stream events and a kill handle.
+*/
+function spawnProvider(provider, options, signal) {
+	const mod = PROVIDERS[provider];
+	const cmd = mod.buildCommand(options);
+	const timeoutMs = options.agent.processTimeoutMs ?? 3e5;
+	logger.debug(`spawning: ${cmd.binary} ${cmd.args.join(" ")} (timeout: ${timeoutMs}ms)`);
+	const baseEnv = cleanEnv();
+	if (cmd.env) for (const [k, v] of Object.entries(cmd.env)) if (v === "") delete baseEnv[k];
+	else baseEnv[k] = v;
+	const proc = spawn(cmd.binary, cmd.args, {
+		cwd: cmd.cwd ?? process.cwd(),
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		env: baseEnv
+	});
+	let stderrBuf = "";
+	proc.stderr.on("data", (chunk) => {
+		stderrBuf += chunk.toString("utf-8");
+	});
+	const timeout = setTimeout(() => {
+		logger.warn(`${cmd.binary} timed out after ${timeoutMs}ms, killing`);
+		gracefulKill(proc);
+	}, timeoutMs);
+	const onAbort = () => gracefulKill(proc);
+	signal.addEventListener("abort", onAbort, { once: true });
+	async function* iterate() {
+		let buffer = "";
+		try {
+			yield* parseStdout(proc, mod, buffer, (b) => {
+				buffer = b;
+			});
+			if (buffer.trim()) yield* mod.parseStreamLine(buffer);
+		} finally {
+			clearTimeout(timeout);
+			signal.removeEventListener("abort", onAbort);
+			if (stderrBuf.trim()) logger.debug(`${cmd.binary} stderr: ${stderrBuf.trim()}`);
+		}
+	}
+	return {
+		events: iterate(),
+		kill: () => gracefulKill(proc)
+	};
+}
+async function* parseStdout(proc, mod, buffer, setBuffer) {
+	const pending = [];
+	let done = false;
+	let error = null;
+	let resolve = null;
+	proc.stdout.on("data", (chunk) => {
+		pending.push(chunk);
+		resolve?.();
+	});
+	proc.on("error", (err) => {
+		error = err.message;
+		done = true;
+		resolve?.();
+	});
+	proc.on("close", () => {
+		done = true;
+		resolve?.();
+	});
+	while (true) {
+		while (pending.length === 0 && !done) await new Promise((r) => {
+			resolve = r;
+		});
+		if (pending.length === 0 && done) break;
+		while (pending.length > 0) {
+			const data = pending.shift().toString("utf-8");
+			logger.debug(`stdout chunk (${data.length} chars)`);
+			const [lines, remaining] = splitLines(buffer, data);
+			buffer = remaining;
+			setBuffer(buffer);
+			for (const line of lines) yield* mod.parseStreamLine(line);
+		}
+	}
+	if (error) yield {
+		type: "error",
+		error
+	};
+}
+
+//#endregion
+//#region src/core/redact.ts
+/** @fileoverview Output redaction: scrubs known secrets and token patterns from agent output. */
+const REDACTED = "[redacted]";
+const SENSITIVE_NAME_RE = /KEY|SECRET|TOKEN|PASSWORD/i;
+/**
+* Token prefix patterns. Each entry is [prefix, minLength] where minLength
+* is the shortest plausible token including the prefix (avoids false positives
+* on short strings that happen to start with a prefix).
+*/
+const TOKEN_PATTERNS = [
+	["xoxb-", 20],
+	["xapp-", 20],
+	["sk-ant-api", 20],
+	["sk-ant-oat", 20],
+	["sk-or-", 20]
+];
+let knownSecrets;
+function collectSecrets() {
+	const secrets = [];
+	for (const [name, value] of Object.entries(process.env)) if (value && SENSITIVE_NAME_RE.test(name) && value.length >= 8) secrets.push(value);
+	secrets.sort((a, b) => b.length - a.length);
+	return secrets;
+}
+function getSecrets() {
+	if (!knownSecrets) knownSecrets = collectSecrets();
+	return knownSecrets;
+}
+function escapeForRegex(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildPatternRegex() {
+	const parts = TOKEN_PATTERNS.map(([prefix, minLength]) => {
+		return `${escapeForRegex(prefix)}[A-Za-z0-9_\\-]{${minLength - prefix.length},}`;
+	});
+	return new RegExp(parts.join("|"), "g");
+}
+const patternRegex = buildPatternRegex();
+/** Replaces known secret values and token patterns in text with [redacted]. */
+function redact(text) {
+	if (!text) return text;
+	let result = text;
+	for (const secret of getSecrets()) if (result.includes(secret)) result = result.replaceAll(secret, REDACTED);
+	result = result.replace(patternRegex, REDACTED);
+	return result;
+}
+
+//#endregion
+//#region src/channel/blocks.ts
+function plain(text) {
+	return {
+		type: "plain_text",
+		text,
+		emoji: true
+	};
+}
+function mrkdwn(text) {
+	return {
+		type: "mrkdwn",
+		text
+	};
+}
+function header(text) {
+	return {
+		type: "header",
+		text: plain(text)
+	};
+}
+function section(text) {
+	return {
+		type: "section",
+		text: mrkdwn(text)
+	};
+}
+function fields(...pairs) {
+	return {
+		type: "section",
+		fields: pairs.map(([label, value]) => mrkdwn(`*${label}:*\n${value}`))
+	};
+}
+function divider() {
+	return { type: "divider" };
+}
+function context(text) {
+	return {
+		type: "context",
+		elements: [mrkdwn(text)]
+	};
+}
+const SUBTYPE_LABELS = {
+	error_max_turns: "Warning: Hit turn limit",
+	error_max_budget_usd: "Warning: Hit budget limit",
+	error_during_execution: "Error during execution",
+	error_max_structured_output_retries: "Structured output failed"
+};
+/**
+* Builds a context footer appended to the streaming message on completion.
+* Uses only non-section blocks (divider + context) so Slack renders the
+* response text from the top-level `text` field, avoiding the 3000-char
+* section limit for long agent responses.
+*/
+function completionFooterBlocks(completion, hasError, birdName, userId) {
+	const parts = [];
+	const subtypeLabel = SUBTYPE_LABELS[completion.subtype];
+	if (subtypeLabel) parts.push(subtypeLabel);
+	if (hasError) parts.push("Error");
+	if (userId) parts.push(`Requested by <@${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("  |  "))];
+}
+/**
+* Standalone completion card for cron/bird results posted to a channel
+* (not in a streaming thread; these need full context).
+*/
+function sessionCompleteBlocks(completion, summary, birdName, userId) {
+	const statusText = SUBTYPE_LABELS[completion.subtype] ?? "Success";
+	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}`));
+	}
+	const contextParts = [];
+	if (birdName) contextParts.push(`Bird: *${birdName}*`);
+	if (userId) contextParts.push(`Triggered by <@${userId}>`);
+	contextParts.push(`${completion.tokensIn.toLocaleString()} in / ${completion.tokensOut.toLocaleString()} out tokens`);
+	blocks.push(context(contextParts.join(" | ")));
+	return blocks;
+}
+function sessionErrorBlocks(errorMessage, opts) {
+	const blocks = [header("Session Failed")];
+	const sectionBlock = {
+		type: "section",
+		text: mrkdwn(`*Error: ${truncate(errorMessage, 200)}*`)
+	};
+	if (opts?.sessionUid) sectionBlock.accessory = {
+		type: "overflow",
+		action_id: "session_error_overflow",
+		options: [{
+			text: plain("Retry"),
+			value: `retry:${opts.sessionUid}`
+		}, {
+			text: plain("View Logs"),
+			value: `logs:${opts.sessionUid}`
+		}]
+	};
+	blocks.push(sectionBlock);
+	const fieldPairs = [];
+	if (opts?.birdName) fieldPairs.push(["Bird", opts.birdName]);
+	if (opts?.durationMs) fieldPairs.push(["Duration", formatDuration(opts.durationMs)]);
+	if (fieldPairs.length > 0) blocks.push(fields(...fieldPairs));
+	return blocks;
+}
+function busyBlocks(activeCount, maxConcurrent) {
+	return [section("*Too many active sessions*"), context(`${activeCount}/${maxConcurrent} slots in use. Try again shortly.`)];
+}
+function noAgentBlocks(channelId) {
+	return [section("*No agent configured for this channel*"), context(`Channel: \`${channelId}\``)];
+}
+function birdCreateModal(defaults) {
+	const scheduleOptions = [
+		{
+			text: plain("Every hour"),
+			value: "0 * * * *"
+		},
+		{
+			text: plain("Every 6 hours"),
+			value: "0 */6 * * *"
+		},
+		{
+			text: plain("Daily at midnight"),
+			value: "0 0 * * *"
+		},
+		{
+			text: plain("Weekly on Monday"),
+			value: "0 0 * * 1"
+		}
+	];
+	const initialSchedule = defaults?.schedule ? scheduleOptions.find((o) => o.value === defaults.schedule) : void 0;
+	return {
+		type: "modal",
+		callback_id: "bird_create",
+		title: plain("Create Bird"),
+		submit: plain("Create"),
+		close: plain("Cancel"),
+		blocks: [
+			{
+				type: "input",
+				block_id: "bird_name",
+				label: plain("Name"),
+				element: {
+					type: "plain_text_input",
+					action_id: "name_input",
+					placeholder: plain("e.g., lint-patrol"),
+					...defaults?.name ? { initial_value: defaults.name } : {}
+				}
+			},
+			{
+				type: "input",
+				block_id: "bird_schedule",
+				label: plain("Schedule"),
+				element: {
+					type: "static_select",
+					action_id: "schedule_select",
+					placeholder: plain("Choose a schedule"),
+					options: scheduleOptions,
+					...initialSchedule ? { initial_option: initialSchedule } : {}
+				}
+			},
+			{
+				type: "input",
+				block_id: "bird_prompt",
+				label: plain("Prompt"),
+				element: {
+					type: "plain_text_input",
+					action_id: "prompt_input",
+					multiline: true,
+					placeholder: plain("What should this bird do?"),
+					...defaults?.prompt ? { initial_value: defaults.prompt } : {}
+				}
+			},
+			{
+				type: "input",
+				block_id: "bird_channel",
+				label: plain("Report to Channel"),
+				element: {
+					type: "conversations_select",
+					action_id: "channel_select",
+					default_to_current_conversation: true
+				}
+			},
+			{
+				type: "input",
+				block_id: "bird_enabled",
+				label: plain("Status"),
+				element: {
+					type: "radio_buttons",
+					action_id: "enabled_radio",
+					options: [{
+						text: plain("Enabled"),
+						value: "enabled"
+					}, {
+						text: plain("Disabled"),
+						value: "disabled"
+					}],
+					initial_option: {
+						text: plain("Enabled"),
+						value: "enabled"
+					}
+				}
+			}
+		]
+	};
+}
+function birdListBlocks(birds) {
+	if (birds.length === 0) return [section("*No birds configured*"), context("Use `/bird create` to create your first bird.")];
+	const blocks = [header("Active Birds")];
+	for (const bird of birds) {
+		const status = bird.enabled ? "[on]" : "[off]";
+		const lastRun = bird.lastStatus ?? "never";
+		blocks.push(section(`${status} *${bird.name}*\n\`${bird.schedule}\` | Agent: \`${bird.agentId}\` | Last: ${lastRun}`));
+	}
+	blocks.push(context(`${birds.length} bird${birds.length === 1 ? "" : "s"} total`));
+	return blocks;
+}
+function birdLogsBlocks(birdName, flights) {
+	if (flights.length === 0) return [section(`*${birdName}* - No flights yet`), context("Trigger with `/bird fly ${birdName}`")];
+	const blocks = [header(`Flights: ${birdName}`)];
+	const lines = flights.map((f) => {
+		const icon = f.status === "success" ? "[ok]" : f.status === "running" ? "[...]" : "[err]";
+		const duration = f.durationMs ? formatDuration(f.durationMs) : "-";
+		const age = formatAge(f.startedAt);
+		const detail = f.error ? truncate(f.error, 80) : duration;
+		return `${icon}  ${shortUid(f.uid)} \`${detail}\` - ${age} ago`;
+	});
+	blocks.push(section(lines.join("\n")));
+	blocks.push(context(`${flights.length} most recent flight${flights.length === 1 ? "" : "s"}`));
+	return blocks;
+}
+function formatAge(isoDate) {
+	const normalized = isoDate.endsWith("Z") ? isoDate : isoDate + "Z";
+	const ms = Date.now() - new Date(normalized).getTime();
+	const minutes = Math.floor(ms / 6e4);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h`;
+	return `${Math.floor(hours / 24)}d`;
+}
+function birdFlyBlocks(birdName, userId) {
+	return [section(`*${birdName}* is taking flight...`), context(`Triggered by <@${userId}>`)];
+}
+function statusBlocks(opts) {
+	const slackStatus = opts.slackConnected ? "Connected" : "Disconnected";
+	return [header("BrowserBird Status"), fields(["Slack", slackStatus], ["Active Sessions", `${opts.activeCount}/${opts.maxConcurrent}`], ["Birds", String(opts.birdCount)], ["Uptime", opts.uptime])];
+}
+function truncate(text, maxLength) {
+	if (text.length <= maxLength) return text;
+	return text.slice(0, maxLength) + "...";
+}
+
+//#endregion
+//#region src/cron/scheduler.ts
+const TICK_INTERVAL_MS = 6e4;
+const MAX_SCHEDULE_ERRORS = 3;
+const systemHandlers = /* @__PURE__ */ new Map();
+function registerSystemCronJobs(config, retentionDays) {
+	const cleanupName = `${SYSTEM_CRON_PREFIX}db_cleanup__`;
+	const optimizeName = `${SYSTEM_CRON_PREFIX}db_optimize__`;
+	systemHandlers.set(cleanupName, () => {
+		expireStaleSessions(config.sessions.ttlHours);
+		const msgs = deleteOldMessages(retentionDays);
+		const runs = deleteOldCronRuns(retentionDays);
+		const jobs = deleteOldJobs(retentionDays);
+		const logs = deleteOldLogs(retentionDays);
+		if (msgs > 0 || runs > 0 || jobs > 0 || logs > 0) {
+			const summary = `${msgs} messages, ${runs} flight logs, ${jobs} jobs, ${logs} logs older than ${retentionDays}d`;
+			logger.info(`system cleanup: ${summary}`);
+			return summary;
+		}
+		return "nothing to clean";
+	});
+	systemHandlers.set(optimizeName, () => {
+		optimizeDatabase();
+		logger.debug("system optimize: database optimized");
+		return "database optimized";
+	});
+	ensureSystemCronJob(cleanupName, "0 */6 * * *", "Database cleanup");
+	ensureSystemCronJob(optimizeName, "0 3 * * *", "Database optimization");
+	logger.info("system birds registered");
+}
+/** Registers the cron_run job handler and starts the scheduler tick loop. */
+function startScheduler(config, signal, deps) {
+	registerSystemCronJobs(config, config.database.retentionDays);
+	registerHandler("cron_run", async (raw) => {
+		const payload = raw;
+		const agent = config.agents.find((a) => a.id === payload.agentId);
+		if (!agent) throw new Error(`agent "${payload.agentId}" not found`);
+		const { events } = spawnProvider(agent.provider, {
+			message: payload.prompt,
+			agent,
+			mcpConfigPath: config.browser.mcpConfigPath
+		}, signal);
+		let result = "";
+		let completion;
+		for await (const event of events) if (event.type === "text_delta") result += redact(event.delta);
+		else if (event.type === "completion") completion = event;
+		else if (event.type === "rate_limit") logger.debug(`bird ${shortUid(payload.cronJobUid)} rate limit window resets ${(/* @__PURE__ */ new Date(event.resetsAt * 1e3)).toISOString()}`);
+		else if (event.type === "error") {
+			const safeError = redact(event.error);
+			if (payload.channelId && deps?.postToSlack) {
+				const blocks = sessionErrorBlocks(safeError, { birdName: agent.name });
+				await deps.postToSlack(payload.channelId, `Bird failed: ${safeError}`, { blocks });
+			}
+			throw new Error(safeError);
+		}
+		if (!result) {
+			logger.info(`bird ${shortUid(payload.cronJobUid)} completed (no output)`);
+			return "completed (no output)";
+		}
+		if (payload.channelId && deps?.postToSlack) {
+			if (completion) {
+				const summary = result.length > 2800 ? result.slice(0, 2800) + "..." : result;
+				const blocks = sessionCompleteBlocks(completion, summary, agent.name);
+				const fallback = `Bird ${agent.name} completed: ${completion.numTurns} turns`;
+				await deps.postToSlack(payload.channelId, fallback, { blocks });
+			} else await deps.postToSlack(payload.channelId, result);
+			logger.info(`bird ${shortUid(payload.cronJobUid)} result posted to ${payload.channelId}`);
+		} else logger.info(`bird ${shortUid(payload.cronJobUid)} completed (${result.length} chars)`);
+		return result;
+	});
+	registerHandler("system_cron_run", (raw) => {
+		const payload = raw;
+		const handler = systemHandlers.get(payload.cronName);
+		if (!handler) throw new Error(`no system handler for "${payload.cronName}"`);
+		const result = handler();
+		logger.info(`${payload.cronName}: ${result ?? "done"}`);
+		return result ?? void 0;
+	});
+	const scheduleCache = /* @__PURE__ */ new Map();
+	const scheduleErrors = /* @__PURE__ */ new Map();
+	const tick = () => {
+		if (signal.aborted) return;
+		const now = /* @__PURE__ */ new Date();
+		const jobs = getEnabledCronJobs();
+		for (const job of jobs) {
+			let schedule = scheduleCache.get(job.uid);
+			if (!schedule) try {
+				schedule = parseCron(job.schedule);
+				scheduleCache.set(job.uid, schedule);
+				scheduleErrors.delete(job.uid);
+			} catch {
+				const count = (scheduleErrors.get(job.uid) ?? 0) + 1;
+				scheduleErrors.set(job.uid, count);
+				if (count >= MAX_SCHEDULE_ERRORS) {
+					logger.warn(`bird ${shortUid(job.uid)}: invalid expression "${job.schedule}" (${count} consecutive failures), disabling`);
+					setCronJobEnabled(job.uid, false);
+					scheduleErrors.delete(job.uid);
+				} else logger.warn(`bird ${shortUid(job.uid)}: invalid expression "${job.schedule}" (attempt ${count}/${MAX_SCHEDULE_ERRORS})`);
+				continue;
+			}
+			if (!matchesCron(schedule, now, job.timezone)) continue;
+			if (!isWithinActiveHours(job.active_hours_start, job.active_hours_end, now, job.timezone)) {
+				logger.debug(`bird ${shortUid(job.uid)} skipped: outside active hours`);
+				continue;
+			}
+			if (hasPendingCronJob(job.uid)) {
+				logger.debug(`bird ${shortUid(job.uid)} skipped: previous run still pending or running`);
+				continue;
+			}
+			const isSystem = job.name.startsWith(SYSTEM_CRON_PREFIX);
+			logger.info(`bird ${shortUid(job.uid)} triggered: "${job.schedule}"`);
+			if (isSystem) enqueue("system_cron_run", {
+				cronJobUid: job.uid,
+				cronName: job.name
+			}, {
+				maxAttempts: 3,
+				timeout: 300,
+				cronJobUid: job.uid
+			});
+			else enqueue("cron_run", {
+				cronJobUid: job.uid,
+				prompt: job.prompt,
+				channelId: job.target_channel_id,
+				agentId: job.agent_id
+			}, {
+				maxAttempts: config.birds.maxAttempts,
+				timeout: 600,
+				cronJobUid: job.uid
+			});
+			updateCronJobStatus(job.uid, "triggered", job.failure_count);
+			broadcastSSE("invalidate", {
+				resource: "birds",
+				cronJobUid: job.uid
+			});
+		}
+	};
+	tick();
+	const timer = setInterval(tick, TICK_INTERVAL_MS);
+	signal.addEventListener("abort", () => {
+		clearInterval(timer);
+		scheduleCache.clear();
+		scheduleErrors.clear();
+	});
+	logger.info("bird scheduler started (60s tick)");
+}
+
+//#endregion
+//#region src/channel/coalesce.ts
+function createCoalescer(config, onDispatch) {
+	const pending = /* @__PURE__ */ new Map();
+	function fire(key) {
+		const batch = pending.get(key);
+		if (!batch) return;
+		pending.delete(key);
+		const [channelId, threadTs] = key.split(":");
+		onDispatch({
+			channelId,
+			threadTs,
+			messages: batch.messages
+		});
+	}
+	function push(channelId, threadTs, userId, text, messageTs) {
+		const key = `${channelId}:${threadTs}`;
+		const message = {
+			userId,
+			text,
+			timestamp: messageTs
+		};
+		const existing = pending.get(key);
+		if (existing) {
+			clearTimeout(existing.timer);
+			existing.messages.push(message);
+			existing.timer = setTimeout(() => fire(key), config.debounceMs);
+		} else {
+			const timer = setTimeout(() => fire(key), config.debounceMs);
+			pending.set(key, {
+				messages: [message],
+				timer
+			});
+		}
+	}
+	function flush() {
+		for (const key of [...pending.keys()]) {
+			const batch = pending.get(key);
+			if (batch) clearTimeout(batch.timer);
+			fire(key);
+		}
+	}
+	function destroy() {
+		for (const batch of pending.values()) clearTimeout(batch.timer);
+		pending.clear();
+	}
+	return {
+		push,
+		flush,
+		destroy
+	};
+}
+
+//#endregion
+//#region src/channel/handler.ts
+function createHandler(client, config, signal, getTeamId) {
+	const locks = /* @__PURE__ */ new Map();
+	let activeSpawns = 0;
+	function getLock(key) {
+		let lock = locks.get(key);
+		if (!lock) {
+			lock = {
+				processing: false,
+				queue: [],
+				killCurrent: null
+			};
+			locks.set(key, lock);
+		}
+		return lock;
+	}
+	function formatPrompt(messages) {
+		if (messages.length === 1) return messages[0].text;
+		return messages.map((m) => {
+			return `[${(/* @__PURE__ */ new Date(Number(m.timestamp) * 1e3)).toISOString().slice(11, 19)}] @${m.userId}: ${m.text}`;
+		}).join("\n");
+	}
+	async function streamToChannel(events, channelId, threadTs, sessionUid, teamId, userId, meta) {
+		const streamer = client.startStream({
+			channelId,
+			threadTs,
+			teamId,
+			userId
+		});
+		let fullText = "";
+		let completion;
+		let hasError = false;
+		for await (const event of events) {
+			if (signal.aborted) break;
+			logger.debug(`stream event: ${event.type}`);
+			switch (event.type) {
+				case "init":
+					updateSessionProviderId(sessionUid, event.sessionId);
+					break;
+				case "text_delta": {
+					const safe = redact(event.delta);
+					fullText += safe;
+					await streamer.append({ markdown_text: safe });
+					break;
+				}
+				case "tool_images":
+					await uploadImages(event.images, channelId, threadTs);
+					break;
+				case "completion":
+					completion = event;
+					logger.info(`completion [${event.subtype}]: ${event.tokensIn}in/${event.tokensOut}out, $${event.costUsd.toFixed(4)}, ${event.numTurns} turns`);
+					logMessage(channelId, threadTs, "bot", "out", fullText, event.tokensIn, event.tokensOut);
+					break;
+				case "rate_limit":
+					logger.debug(`rate limit window resets ${(/* @__PURE__ */ new Date(event.resetsAt * 1e3)).toISOString()}`);
+					break;
+				case "error": {
+					hasError = true;
+					const safeError = redact(event.error);
+					logger.error(`agent error: ${safeError}`);
+					insertLog("error", "spawn", safeError, channelId);
+					await streamer.append({ markdown_text: `\n\nError: ${safeError}` });
+					break;
+				}
+			}
+		}
+		const footerBlocks = completion ? completionFooterBlocks(completion, hasError, meta.birdName, userId) : void 0;
+		await streamer.stop(footerBlocks ? { blocks: footerBlocks } : {});
+	}
+	async function uploadImages(images, channelId, threadTs) {
+		for (let i = 0; i < images.length; i++) {
+			const img = images[i];
+			const content = Buffer.from(img.data, "base64");
+			const ext = img.mediaType === "image/jpeg" ? "jpg" : "png";
+			const filename = `screenshot-${i + 1}.${ext}`;
+			try {
+				await client.uploadFile(channelId, threadTs, content, filename, `Screenshot ${i + 1}`);
+			} catch (err) {
+				logger.warn(`image upload failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+	}
+	async function handle(dispatch) {
+		const { channelId, threadTs, messages } = dispatch;
+		const key = `${channelId}:${threadTs}`;
+		const lock = getLock(key);
+		if (lock.processing) {
+			lock.queue.push(dispatch);
+			try {
+				await client.postEphemeral(channelId, threadTs, messages[messages.length - 1].userId, "Got it, I'll get to this after my current response.");
+			} catch {}
+			return;
+		}
+		if (activeSpawns >= config.sessions.maxConcurrent) {
+			const blocks = busyBlocks(activeSpawns, config.sessions.maxConcurrent);
+			await client.postMessage(channelId, threadTs, "Too many active sessions. Try again shortly.", { blocks });
+			logger.warn("max concurrent sessions reached");
+			return;
+		}
+		lock.processing = true;
+		activeSpawns++;
+		let sessionUid;
+		try {
+			const resolved = resolveSession(channelId, threadTs, config);
+			if (!resolved) {
+				const blocks = noAgentBlocks(channelId);
+				await client.postMessage(channelId, threadTs, "No agent configured for this channel.", { blocks });
+				return;
+			}
+			const { session, agent, isNew } = resolved;
+			sessionUid = session.uid;
+			for (const msg of messages) logMessage(channelId, threadTs, msg.userId, "in", msg.text);
+			touchSession(session.uid, messages.length + 1);
+			broadcastSSE("invalidate", { resource: "sessions" });
+			const prompt = formatPrompt(messages);
+			const userId = messages[messages.length - 1].userId;
+			const existingSessionId = isNew ? void 0 : session.provider_session_id || void 0;
+			const { events, kill } = spawnProvider(agent.provider, {
+				message: prompt,
+				sessionId: existingSessionId,
+				agent,
+				mcpConfigPath: config.browser.mcpConfigPath
+			}, signal);
+			lock.killCurrent = kill;
+			client.setStatus?.(channelId, threadTs, "is thinking...").catch(() => {});
+			if (isNew) {
+				const title = prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt;
+				client.setTitle?.(channelId, threadTs, title).catch(() => {});
+			}
+			await streamToChannel(events, channelId, threadTs, session.uid, getTeamId(), userId, { birdName: agent.name });
+		} catch (err) {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			logger.error(`handler error: ${errMsg}`);
+			insertLog("error", "handler", errMsg, channelId);
+			try {
+				const blocks = sessionErrorBlocks(errMsg, { sessionUid });
+				await client.postMessage(channelId, threadTs, `Something went wrong: ${errMsg}`, { blocks });
+			} catch {}
+		} finally {
+			activeSpawns--;
+			lock.processing = false;
+			lock.killCurrent = null;
+			const next = lock.queue.shift();
+			if (next) handle(next).catch((err) => {
+				logger.error(`dispatch error: ${err instanceof Error ? err.message : String(err)}`);
+			});
+			else if (lock.queue.length === 0) locks.delete(key);
+		}
+	}
+	function activeCount() {
+		return activeSpawns;
+	}
+	function killAll() {
+		for (const lock of locks.values()) {
+			lock.killCurrent?.();
+			lock.queue.length = 0;
+		}
+		locks.clear();
+	}
+	return {
+		handle,
+		activeCount,
+		killAll
+	};
+}
+
+//#endregion
+//#region src/channel/commands.ts
+const startTime = Date.now();
+function formatUptime() {
+	const ms = Date.now() - startTime;
+	const hours = Math.floor(ms / 36e5);
+	const minutes = Math.floor(ms % 36e5 / 6e4);
+	if (hours === 0) return `${minutes}m`;
+	return `${hours}h ${minutes}m`;
+}
+async function handleSlashCommand(body, webClient, channelClient, config, status) {
+	const parts = body.text.trim().split(/\s+/);
+	const subcommand = parts[0] ?? "help";
+	async function say(message) {
+		await webClient.chat.postMessage({
+			channel: body.channel_id,
+			text: message.text,
+			...message.blocks ? { blocks: message.blocks } : {}
+		});
+	}
+	function findBird(nameOrUid) {
+		const byUid = resolveByUid("cron_jobs", nameOrUid);
+		if (byUid && "row" in byUid) return byUid.row;
+		return listCronJobs(1, 100, false).items.find((b) => b.name === nameOrUid);
+	}
+	switch (subcommand) {
+		case "list": {
+			const birds = listCronJobs(1, 20, false).items.map((b) => ({
+				uid: b.uid,
+				name: b.name,
+				schedule: b.schedule,
+				enabled: b.enabled === 1,
+				lastStatus: b.last_status,
+				agentId: b.agent_id
+			}));
+			const blocks = birdListBlocks(birds);
+			await say({
+				text: `${birds.length} bird${birds.length === 1 ? "" : "s"} configured`,
+				blocks
+			});
+			break;
+		}
+		case "fly": {
+			const birdName = parts.slice(1).join(" ");
+			if (!birdName) {
+				await say({ text: "Usage: `/bird fly <name or id>`" });
+				return;
+			}
+			const bird = findBird(birdName);
+			if (!bird) {
+				await say({ text: `Bird not found: \`${birdName}\`` });
+				return;
+			}
+			enqueue("cron_run", {
+				cronJobUid: bird.uid,
+				prompt: bird.prompt,
+				channelId: bird.target_channel_id,
+				agentId: bird.agent_id
+			}, {
+				maxAttempts: config.birds.maxAttempts,
+				timeout: 600,
+				cronJobUid: bird.uid
+			});
+			const blocks = birdFlyBlocks(bird.name, body.user_id);
+			await say({
+				text: `${bird.name} is taking flight...`,
+				blocks
+			});
+			logger.info(`/bird fly: ${bird.name} triggered by ${body.user_id}`);
+			break;
+		}
+		case "enable":
+		case "disable": {
+			const birdName = parts.slice(1).join(" ");
+			if (!birdName) {
+				await say({ text: `Usage: \`/bird ${subcommand} <name or id>\`` });
+				return;
+			}
+			const bird = findBird(birdName);
+			if (!bird) {
+				await say({ text: `Bird not found: \`${birdName}\`` });
+				return;
+			}
+			const enabling = subcommand === "enable";
+			if (bird.enabled === 1 === enabling) {
+				await say({ text: `*${bird.name}* is already ${subcommand}d.` });
+				return;
+			}
+			setCronJobEnabled(bird.uid, enabling);
+			await say({ text: `*${bird.name}* ${subcommand}d.` });
+			logger.info(`/bird ${subcommand}: ${bird.name} by ${body.user_id}`);
+			break;
+		}
+		case "logs": {
+			const birdName = parts.slice(1).join(" ");
+			if (!birdName) {
+				await say({ text: "Usage: `/bird logs <name or id>`" });
+				return;
+			}
+			const bird = findBird(birdName);
+			if (!bird) {
+				await say({ text: `Bird not found: \`${birdName}\`` });
+				return;
+			}
+			const flights = listFlights(1, 5, { birdUid: bird.uid });
+			const mapped = flights.items.map((f) => {
+				const durationMs = f.finished_at && f.started_at ? new Date(f.finished_at).getTime() - new Date(f.started_at).getTime() : void 0;
+				return {
+					uid: f.uid,
+					status: f.status,
+					startedAt: f.started_at,
+					durationMs,
+					error: f.error ?? void 0
+				};
+			});
+			const blocks = birdLogsBlocks(bird.name, mapped);
+			await say({
+				text: `${flights.totalItems} flight${flights.totalItems === 1 ? "" : "s"} for ${bird.name}`,
+				blocks
+			});
+			break;
+		}
+		case "create": {
+			if (!channelClient.openModal) {
+				await say({ text: "Modals are not supported by this adapter." });
+				return;
+			}
+			const modal = birdCreateModal();
+			await channelClient.openModal(body.trigger_id, modal);
+			break;
+		}
+		case "status": {
+			const cronJobs = listCronJobs(1, 1, false);
+			await say({
+				text: "BrowserBird status",
+				blocks: statusBlocks({
+					slackConnected: status.slackConnected(),
+					activeCount: status.activeCount(),
+					maxConcurrent: config.sessions.maxConcurrent,
+					birdCount: cronJobs.totalItems,
+					uptime: formatUptime()
+				})
+			});
+			break;
+		}
+		default: await say({ text: [
+			"*Usage:* `/bird <command>`",
+			"",
+			"`/bird list` - Show all configured birds",
+			"`/bird fly <name>` - Trigger a bird immediately",
+			"`/bird logs <name>` - Show recent flights",
+			"`/bird enable <name>` - Enable a bird",
+			"`/bird disable <name>` - Disable a bird",
+			"`/bird create` - Create a new bird (opens form)",
+			"`/bird status` - Show daemon status"
+		].join("\n") });
+	}
+}
+
+//#endregion
+//#region src/channel/slack.ts
+var SlackChannelClient = class {
+	web;
+	constructor(web) {
+		this.web = web;
+	}
+	async postMessage(channelId, threadTs, text, opts) {
+		return (await this.web.chat.postMessage({
+			channel: channelId,
+			thread_ts: threadTs,
+			text,
+			...opts?.blocks ? { blocks: opts.blocks } : {}
+		})).ts ?? "";
+	}
+	async postEphemeral(channelId, threadTs, userId, text, opts) {
+		await this.web.chat.postEphemeral({
+			channel: channelId,
+			thread_ts: threadTs,
+			user: userId,
+			text,
+			...opts?.blocks ? { blocks: opts.blocks } : {}
+		});
+	}
+	async openModal(triggerId, view) {
+		await this.web.views.open({
+			trigger_id: triggerId,
+			view
+		});
+	}
+	async uploadFile(channelId, threadTs, content, filename, title) {
+		const upload = await this.web.files.getUploadURLExternal({
+			filename,
+			length: content.byteLength
+		});
+		if (!upload.upload_url || !upload.file_id) return;
+		await fetch(upload.upload_url, {
+			method: "POST",
+			body: new Uint8Array(content)
+		});
+		await this.web.files.completeUploadExternal({
+			files: [{
+				id: upload.file_id,
+				title
+			}],
+			channel_id: channelId,
+			thread_ts: threadTs
+		});
+	}
+	startStream(opts) {
+		return this.web.chatStream({
+			channel: opts.channelId,
+			thread_ts: opts.threadTs,
+			recipient_team_id: opts.teamId,
+			recipient_user_id: opts.userId,
+			task_display_mode: "timeline",
+			buffer_size: 128
+		});
+	}
+	async setStatus(channelId, threadTs, status) {
+		await this.web.assistant.threads.setStatus({
+			channel_id: channelId,
+			thread_ts: threadTs,
+			status
+		});
+	}
+	async setTitle(channelId, threadTs, title) {
+		await this.web.assistant.threads.setTitle({
+			channel_id: channelId,
+			thread_ts: threadTs,
+			title
+		});
+	}
+	async setSuggestedPrompts(channelId, threadTs, prompts) {
+		await this.web.assistant.threads.setSuggestedPrompts({
+			channel_id: channelId,
+			thread_ts: threadTs,
+			prompts
+		});
+	}
+};
+const IGNORED_SUBTYPES = new Set([
+	"bot_message",
+	"message_changed",
+	"message_deleted",
+	"message_replied",
+	"channel_join",
+	"channel_leave",
+	"channel_topic",
+	"channel_purpose",
+	"channel_name",
+	"channel_archive",
+	"channel_unarchive",
+	"file_share",
+	"pinned_item",
+	"unpinned_item"
+]);
+const DEDUP_TTL_MS = 3e4;
+const DEDUP_CLEANUP_MS = 6e4;
+function logDispatchError(err) {
+	logger.error(`dispatch error: ${err instanceof Error ? err.message : String(err)}`);
+}
+function createSlackChannel(config, signal) {
+	const recentEvents = /* @__PURE__ */ new Map();
+	let botUserId = "";
+	let teamId = "";
+	const socketClient = new SocketModeClient({
+		appToken: config.slack.appToken,
+		logLevel: LogLevel.WARN,
+		clientPingTimeout: 15e3,
+		serverPingTimeout: 6e4
+	});
+	const webClient = new WebClient(config.slack.botToken);
+	const channelClient = new SlackChannelClient(webClient);
+	const handler = createHandler(channelClient, config, signal, () => teamId);
+	const coalescer = createCoalescer(config.slack.coalesce, (dispatch) => {
+		handler.handle(dispatch).catch(logDispatchError);
+	});
+	const dedupTimer = setInterval(() => {
+		const cutoff = Date.now() - DEDUP_TTL_MS;
+		for (const [key, ts] of recentEvents) if (ts < cutoff) recentEvents.delete(key);
+	}, DEDUP_CLEANUP_MS);
+	signal.addEventListener("abort", () => {
+		clearInterval(dedupTimer);
+	});
+	function isDuplicate(body) {
+		const eventId = body["event_id"];
+		if (!eventId) return false;
+		if (recentEvents.has(eventId)) return true;
+		recentEvents.set(eventId, Date.now());
+		return false;
+	}
+	socketClient.on("message", async ({ ack, body, event }) => {
+		await ack();
+		if (!event) return;
+		if (event["user"] === botUserId) return;
+		const text = event["text"];
+		if (!text) return;
+		const subtype = event["subtype"];
+		if (subtype && IGNORED_SUBTYPES.has(subtype)) return;
+		if (event["bot_id"]) return;
+		if (isDuplicate(body)) return;
+		const isDm = event["channel_type"] === "im";
+		if (!isDm && config.slack.requireMention) return;
+		const channelId = event["channel"];
+		if (!isChannelAllowed(channelId, config.slack.channels)) return;
+		if (!isDm && isQuietHours(config.slack.quietHours)) return;
+		const threadTs = event["thread_ts"] ?? event["ts"];
+		const userId = event["user"] ?? "unknown";
+		const messageTs = event["ts"];
+		const cleanText = stripMention(text);
+		if (!cleanText.trim()) return;
+		if (isDm && config.slack.coalesce.bypassDms) handler.handle({
+			channelId,
+			threadTs,
+			messages: [{
+				userId,
+				text: cleanText,
+				timestamp: messageTs
+			}]
+		}).catch(logDispatchError);
+		else coalescer.push(channelId, threadTs, userId, cleanText, messageTs);
+	});
+	if (config.slack.requireMention) socketClient.on("app_mention", async ({ ack, body, event }) => {
+		await ack();
+		if (!event) return;
+		if (isDuplicate(body)) return;
+		const channelId = event["channel"];
+		if (!isChannelAllowed(channelId, config.slack.channels)) return;
+		if (isQuietHours(config.slack.quietHours)) return;
+		const messageTs = event["ts"];
+		if (!messageTs) return;
+		const threadTs = event["thread_ts"] ?? messageTs;
+		const userId = event["user"] ?? "unknown";
+		const text = stripMention(event["text"] ?? "");
+		if (!text.trim()) return;
+		coalescer.push(channelId, threadTs, userId, text, messageTs);
+	});
+	socketClient.on("assistant_thread_started", 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;
+		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(() => {});
+	});
+	socketClient.on("assistant_thread_context_changed", async ({ ack }) => {
+		await ack();
+	});
+	let connected = false;
+	const statusProvider = {
+		slackConnected: () => connected,
+		activeCount: () => handler.activeCount()
+	};
+	socketClient.on("slash_commands", async ({ ack, body }) => {
+		await ack();
+		const commandBody = body;
+		if (commandBody.command !== "/bird") return;
+		try {
+			await handleSlashCommand(commandBody, webClient, channelClient, config, statusProvider);
+		} catch (err) {
+			logger.error(`/bird command error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	});
+	socketClient.on("interactive", async ({ ack, body }) => {
+		await ack();
+		const interactionType = body["type"];
+		if (interactionType === "view_submission") {
+			const view = body["view"];
+			if (view?.["callback_id"] === "bird_create") await handleBirdCreateSubmission(view, webClient, config.timezone);
+		}
+		if (interactionType === "block_actions") {
+			const actionsArr = body["actions"];
+			const channel = body["channel"]?.["id"];
+			const user = body["user"]?.["id"];
+			if (!actionsArr || !channel) return;
+			for (const action of actionsArr) {
+				if (action["action_id"] !== "session_error_overflow") continue;
+				const selected = action["selected_option"]?.["value"];
+				if (!selected) continue;
+				if (selected.startsWith("retry:")) {
+					const sessionUid = selected.slice(6);
+					if (!sessionUid) continue;
+					await handleSessionRetry(sessionUid, channel, user ?? "unknown", config, handler);
+				}
+			}
+		}
+	});
+	const MAX_CONSECUTIVE_FAILURES = 5;
+	socketClient.on("connected", () => {
+		connected = true;
+		logger.success("slack connected");
+	});
+	socketClient.on("reconnecting", () => {
+		connected = false;
+		logger.info("slack reconnecting...");
+	});
+	socketClient.on("disconnected", () => {
+		connected = false;
+		logger.warn("slack disconnected");
+	});
+	socketClient.on("close", () => {
+		const failures = socketClient["numOfConsecutiveReconnectionFailures"];
+		if (failures != null && failures > MAX_CONSECUTIVE_FAILURES) {
+			socketClient["numOfConsecutiveReconnectionFailures"] = 1;
+			logger.info("reset reconnection back-off counter");
+		}
+	});
+	async function resolveChannelNames() {
+		const namesToResolve = /* @__PURE__ */ new Set();
+		function collectNames(channels) {
+			for (const ch of channels) if (ch !== "*" && !ch.startsWith("C") && !ch.startsWith("D") && !ch.startsWith("G")) namesToResolve.add(ch);
+		}
+		collectNames(config.slack.channels);
+		for (const agent of config.agents) collectNames(agent.channels);
+		if (namesToResolve.size === 0) return;
+		const nameToId = /* @__PURE__ */ new Map();
+		try {
+			let cursor;
+			do {
+				const result = await webClient.conversations.list({
+					types: "public_channel,private_channel",
+					limit: 200,
+					exclude_archived: true,
+					cursor
+				});
+				for (const ch of result.channels ?? []) if (ch.name && ch.id && namesToResolve.has(ch.name)) nameToId.set(ch.name, ch.id);
+				cursor = result.response_metadata?.next_cursor || void 0;
+			} while (cursor);
+		} catch (err) {
+			logger.warn(`failed to resolve channel names: ${err instanceof Error ? err.message : String(err)}`);
+			return;
+		}
+		function resolveList(channels, label) {
+			return channels.map((ch) => {
+				const resolved = nameToId.get(ch);
+				if (resolved) {
+					logger.info(`${label}: resolved channel "${ch}" -> ${resolved}`);
+					return resolved;
+				}
+				if (namesToResolve.has(ch)) logger.warn(`${label}: channel "${ch}" not found in workspace`);
+				return ch;
+			});
+		}
+		config.slack.channels = resolveList(config.slack.channels, "slack");
+		for (const agent of config.agents) agent.channels = resolveList(agent.channels, `agent "${agent.id}"`);
+	}
+	async function start() {
+		const authResult = await webClient.auth.test();
+		botUserId = authResult.user_id ?? "";
+		teamId = authResult.team_id ?? "";
+		logger.info(`authenticated as ${authResult.user} (team: ${teamId})`);
+		await resolveChannelNames();
+		await socketClient.start();
+		connected = true;
+	}
+	async function stop() {
+		connected = false;
+		coalescer.destroy();
+		handler.killAll();
+		clearInterval(dedupTimer);
+		await socketClient.disconnect();
+		logger.info("slack stopped");
+	}
+	function isConnected() {
+		return connected;
+	}
+	async function postMessage(channel, text, opts) {
+		await webClient.chat.postMessage({
+			channel,
+			text,
+			...opts?.blocks ? { blocks: opts.blocks } : {}
+		});
+	}
+	return {
+		start,
+		stop,
+		isConnected,
+		activeCount: () => handler.activeCount(),
+		postMessage
+	};
+}
+async function handleBirdCreateSubmission(view, webClient, defaultTimezone) {
+	try {
+		const stateValues = view["state"]?.["values"] ?? {};
+		const name = stateValues["bird_name"]?.["name_input"]?.["value"] ?? "";
+		const schedule = (stateValues["bird_schedule"]?.["schedule_select"]?.["selected_option"])?.["value"];
+		const prompt = stateValues["bird_prompt"]?.["prompt_input"]?.["value"] ?? "";
+		const channelId = stateValues["bird_channel"]?.["channel_select"]?.["selected_conversation"] ?? "";
+		const enabledValue = (stateValues["bird_enabled"]?.["enabled_radio"]?.["selected_option"])?.["value"];
+		if (!name || !schedule || !prompt) {
+			logger.warn("bird_create submission missing required fields");
+			return;
+		}
+		const { createCronJob, setCronJobEnabled } = await import("./db-BsYEYsul.mjs").then((n) => n.t);
+		const bird = createCronJob(name, schedule, prompt, channelId || void 0, "default", defaultTimezone);
+		if (enabledValue !== "enabled") setCronJobEnabled(bird.uid, false);
+		await webClient.chat.postMessage({
+			channel: channelId || "general",
+			text: `Bird *${name}* created. Schedule: \`${schedule}\``
+		});
+		logger.info(`bird created via modal: ${name}`);
+	} catch (err) {
+		logger.error(`bird_create submission error: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+async function handleSessionRetry(sessionUid, channelId, userId, config, handler) {
+	try {
+		const { getSession, getLastInboundMessage } = await import("./db-BsYEYsul.mjs").then((n) => n.t);
+		const session = getSession(sessionUid);
+		if (!session) {
+			logger.warn(`retry: session ${sessionUid} not found`);
+			return;
+		}
+		const lastMsg = getLastInboundMessage(session.channel_id, session.thread_id);
+		if (!lastMsg) {
+			logger.warn(`retry: no inbound message for session ${sessionUid}`);
+			return;
+		}
+		handler.handle({
+			channelId: session.channel_id,
+			threadTs: session.thread_id ?? lastMsg.timestamp,
+			messages: [{
+				userId,
+				text: lastMsg.content,
+				timestamp: lastMsg.timestamp
+			}]
+		}).catch(logDispatchError);
+		logger.info(`retry: session ${sessionUid} re-dispatched by ${userId}`);
+	} catch (err) {
+		logger.error(`retry error: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+function isChannelAllowed(channelId, channels) {
+	if (channels.includes("*")) return true;
+	return channels.includes(channelId);
+}
+function isQuietHours(quietHours) {
+	if (!quietHours.enabled) return false;
+	return isWithinTimeRange(quietHours.start, quietHours.end, /* @__PURE__ */ new Date(), quietHours.timezone);
+}
+function stripMention(text) {
+	return text.replace(/^\s*<@[A-Z0-9]+>\s*/i, "").trim();
+}
+
+//#endregion
+//#region src/daemon.ts
+/** @fileoverview Main orchestrator process: starts all subsystems and handles graceful shutdown. */
+const controller = new AbortController();
+const SHUTDOWN_TIMEOUT_MS = 5e3;
+function setupShutdown() {
+	let shutting = false;
+	const shutdown = (signal) => {
+		if (shutting) {
+			logger.info(`received ${signal} again, forcing exit`);
+			process.exit(1);
+		}
+		shutting = true;
+		logger.info(`received ${signal}, shutting down...`);
+		controller.abort();
+		setTimeout(() => {
+			logger.warn("graceful shutdown timed out, forcing exit");
+			process.exit(1);
+		}, SHUTDOWN_TIMEOUT_MS).unref();
+	};
+	process.on("SIGINT", () => shutdown("SIGINT"));
+	process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+const stubDeps = {
+	slackConnected: () => false,
+	activeProcessCount: () => 0,
+	serviceHealth: () => ({
+		agent: { available: false },
+		browser: { connected: false }
+	})
+};
+async function startDaemon(options) {
+	setupShutdown();
+	process.stderr.write(BANNER + "\n\n");
+	if (options.flags.verbose) logger.setLevel("debug");
+	const configPath = resolve(options.flags.config ?? process.env["BROWSERBIRD_CONFIG"] ?? "browserbird.json");
+	const envPath = resolve(".env");
+	openDatabase(resolveDbPath(options.flags.db));
+	startWorker(controller.signal);
+	loadDotEnv(envPath);
+	let currentConfig = loadConfig(configPath);
+	let slackHandle = null;
+	let setupMode = true;
+	const getConfig = () => currentConfig;
+	const getDeps = () => {
+		if (setupMode) return stubDeps;
+		return {
+			slackConnected: () => slackHandle?.isConnected() ?? false,
+			activeProcessCount: () => slackHandle?.activeCount() ?? 0,
+			serviceHealth: () => getServiceHealth(currentConfig)
+		};
+	};
+	const startFull = (config) => {
+		currentConfig = config;
+		setupMode = false;
+		logger.info("connecting to slack...");
+		slackHandle = createSlackChannel(config, controller.signal);
+		logger.info("starting scheduler...");
+		startScheduler(config, controller.signal, { postToSlack: (channel, text, opts) => slackHandle.postMessage(channel, text, opts) });
+		slackHandle.start().catch((err) => {
+			logger.error(`slack failed to start: ${err instanceof Error ? err.message : String(err)}`);
+		});
+		startHealthChecks(config, controller.signal);
+		logger.success("browserbird orchestrator started");
+		logger.info(`agents: ${config.agents.map((a) => a.id).join(", ")}`);
+		logger.info(`max concurrent sessions: ${config.sessions.maxConcurrent}`);
+		if (config.browser.enabled) logger.info(`browser mode: ${process.env["BROWSER_MODE"] ?? "persistent"}`);
+	};
+	const onLaunch = async () => {
+		loadDotEnv(envPath);
+		const config = loadConfig(configPath);
+		if (!config.slack.botToken || !config.slack.appToken) throw new Error("Slack tokens are required to launch");
+		startFull(config);
+	};
+	const reloadConfig = () => {
+		loadDotEnv(envPath);
+		currentConfig = loadConfig(configPath);
+		logger.info("config reloaded");
+	};
+	if (hasSlackTokens(configPath)) {
+		if (!currentConfig.slack.botToken || !currentConfig.slack.appToken) throw new Error("slack tokens not resolvable (set SLACK_BOT_TOKEN/SLACK_APP_TOKEN or configure in browserbird.json)");
+		setSetting("onboarding_completed", "true");
+		startFull(currentConfig);
+	} else {
+		setSetting("onboarding_completed", "");
+		logger.info("starting in setup mode (onboarding not completed)");
+	}
+	let webServer = null;
+	const webConfig = getConfig();
+	if (webConfig.web.enabled) {
+		logger.info(`starting web server on port ${webConfig.web.port}...`);
+		webServer = createWebServer(getConfig, controller.signal, getDeps, {
+			configPath,
+			onLaunch,
+			onConfigReload: reloadConfig
+		});
+		await webServer.start();
+	}
+	if (setupMode) logger.info("waiting for onboarding to complete via web UI");
+	await new Promise((resolvePromise) => {
+		controller.signal.addEventListener("abort", () => {
+			resolvePromise();
+		});
+	});
+	if (webServer) await webServer.stop();
+	if (slackHandle) await Promise.race([slackHandle.stop(), new Promise((r) => setTimeout(r, 3e3))]);
+	closeDatabase();
+	logger.info("browserbird stopped");
+}
+
+//#endregion
+//#region src/cli/sessions.ts
+/** @fileoverview Sessions command: list and inspect sessions. */
+const SESSIONS_HELP = `
+${c("cyan", "usage:")} browserbird sessions <subcommand> [options]
+
+manage sessions.
+
+${c("dim", "subcommands:")}
+
+  ${c("cyan", "list")}          list recent sessions
+  ${c("cyan", "logs")} <uid>    show session detail and message history
+
+${c("dim", "options:")}
+
+  ${c("yellow", "--json")}       output as JSON (with list, logs)
+  ${c("yellow", "--db")} <path>  database file path (env: BROWSERBIRD_DB)
+  ${c("yellow", "-h, --help")}   show this help
+`.trim();
+function handleSessions(argv) {
+	const subcommand = argv[0] ?? "list";
+	const args = argv.slice(1);
+	const dbPath = resolveDbPathFromArgv(argv);
+	const { values, positionals } = parseArgs({
+		args,
+		options: { json: {
+			type: "boolean",
+			default: false
+		} },
+		allowPositionals: true,
+		strict: false
+	});
+	if (subcommand === "list") {
+		openDatabase(dbPath);
+		try {
+			const { items, totalItems } = listSessions(1, 20);
+			if (values.json) {
+				console.log(JSON.stringify(items, null, 2));
+				return;
+			}
+			console.log(`sessions (${totalItems} total):`);
+			if (items.length === 0) {
+				console.log("\n  no sessions found");
+				return;
+			}
+			console.log("");
+			printTable([
+				"uid",
+				"channel",
+				"agent",
+				"messages",
+				"last active"
+			], items.map((s) => [
+				c("dim", shortUid(s.uid)),
+				s.channel_id,
+				s.agent_id,
+				String(s.message_count),
+				s.last_active.slice(0, 19)
+			]));
+		} finally {
+			closeDatabase();
+		}
+		return;
+	}
+	if (subcommand !== "logs") {
+		unknownSubcommand(subcommand, "sessions", ["list", "logs"]);
+		return;
+	}
+	const uidPrefix = positionals[0];
+	if (!uidPrefix) {
+		logger.error("usage: browserbird sessions logs <uid>");
+		process.exitCode = 1;
+		return;
+	}
+	openDatabase(dbPath);
+	try {
+		const result = resolveByUid("sessions", uidPrefix);
+		if (!result) {
+			logger.error(`session ${uidPrefix} not found`);
+			process.exitCode = 1;
+			return;
+		}
+		if ("ambiguous" in result) {
+			logger.error(`ambiguous session ID "${uidPrefix}" matches ${result.count} sessions, use a longer prefix`);
+			process.exitCode = 1;
+			return;
+		}
+		const session = result.row;
+		const tokenStats = getSessionTokenStats(session.channel_id, session.thread_id);
+		if (values.json) {
+			const msgResult = getSessionMessages(session.channel_id, session.thread_id, 1, 50);
+			console.log(JSON.stringify({
+				session,
+				messages: msgResult.items
+			}, null, 2));
+			return;
+		}
+		console.log(`session ${c("cyan", shortUid(session.uid))}`);
+		console.log(c("dim", "------------------"));
+		console.log(`${c("dim", "uid:")}          ${session.uid}`);
+		console.log(`${c("dim", "channel:")}      ${session.channel_id}`);
+		console.log(`${c("dim", "thread:")}       ${session.thread_id ?? "(none)"}`);
+		console.log(`${c("dim", "agent:")}        ${session.agent_id}`);
+		console.log(`${c("dim", "provider id:")}  ${session.provider_session_id}`);
+		console.log(`${c("dim", "created:")}      ${session.created_at}`);
+		console.log(`${c("dim", "last active:")}  ${session.last_active}`);
+		console.log(`${c("dim", "messages:")}     ${session.message_count}`);
+		console.log(`${c("dim", "tokens:")}       ${tokenStats.totalTokensIn} in / ${tokenStats.totalTokensOut} out`);
+		console.log("");
+		const msgResult = getSessionMessages(session.channel_id, session.thread_id, 1, 50);
+		if (msgResult.items.length === 0) {
+			console.log("no messages recorded.");
+			return;
+		}
+		console.log(`messages (${msgResult.totalItems} total, showing page 1 of ${msgResult.totalPages}):`);
+		console.log("------------------");
+		for (const msg of msgResult.items) {
+			const dir = msg.direction === "in" ? c("green", "->") : c("cyan", "<-");
+			const tokens = msg.tokens_in != null || msg.tokens_out != null ? `  [in:${msg.tokens_in ?? 0} out:${msg.tokens_out ?? 0}]` : "";
+			const preview = (msg.content ?? "").slice(0, 120);
+			const truncated = (msg.content?.length ?? 0) > 120 ? "..." : "";
+			console.log(`${dir} ${msg.user_id}  ${msg.created_at}${tokens}`);
+			if (preview) console.log(`   ${preview}${truncated}`);
+		}
+	} finally {
+		closeDatabase();
+	}
+}
+
+//#endregion
+//#region src/cli/birds.ts
+/** @fileoverview Birds command: manage scheduled birds (cron jobs). */
+const BIRDS_HELP = `
+${c("cyan", "usage:")} browserbird birds <subcommand> [options]
+
+manage scheduled birds.
+
+${c("dim", "subcommands:")}
+
+  ${c("cyan", "list")}                         list all birds
+  ${c("cyan", "add")} <schedule> <prompt>      add a new bird
+  ${c("cyan", "edit")} <uid>                   edit a bird
+  ${c("cyan", "remove")} <uid>                 remove a bird
+  ${c("cyan", "enable")} <uid>                 enable a bird
+  ${c("cyan", "disable")} <uid>                disable a bird
+  ${c("cyan", "fly")} <uid>                    trigger a bird manually
+  ${c("cyan", "flights")} <uid>                show flight history for a bird
+
+${c("dim", "options:")}
+
+  ${c("yellow", "--channel")} <id>       target slack channel
+  ${c("yellow", "--agent")} <id>         target agent id
+  ${c("yellow", "--schedule")} <expr>    cron schedule expression
+  ${c("yellow", "--prompt")} <text>      prompt text
+  ${c("yellow", "--timezone")} <tz>      IANA timezone (default: UTC)
+  ${c("yellow", "--active-hours")} <range>  restrict runs to a time window (e.g. "09:00-17:00")
+  ${c("yellow", "--limit")} <n>          number of flights to show (default: 10)
+  ${c("yellow", "--json")}              output as JSON (with list, flights)
+  ${c("yellow", "--db")} <path>          database file path (env: BROWSERBIRD_DB)
+  ${c("yellow", "-h, --help")}           show this help
+`.trim();
+function statusColor(status) {
+	if (status == null) return "-";
+	switch (status) {
+		case "success":
+		case "completed": return c("green", status);
+		case "running": return c("blue", status);
+		case "failed": return c("red", status);
+		default: return status;
+	}
+}
+function parseActiveHours(raw) {
+	const match = raw.match(/^(\d{1,2}:\d{2})\s*-\s*(\d{1,2}:\d{2})$/);
+	if (!match) return null;
+	return {
+		start: match[1],
+		end: match[2]
+	};
+}
+function resolveBird(uidPrefix) {
+	const result = resolveByUid("cron_jobs", uidPrefix);
+	if (!result) {
+		logger.error(`bird ${uidPrefix} not found`);
+		process.exitCode = 1;
+		return;
+	}
+	if ("ambiguous" in result) {
+		logger.error(`ambiguous bird ID "${uidPrefix}" matches ${result.count} birds, use a longer prefix`);
+		process.exitCode = 1;
+		return;
+	}
+	return result.row;
+}
+function handleBirds(argv) {
+	const subcommand = argv[0] ?? "list";
+	const { values, positionals } = parseArgs({
+		args: argv.slice(1),
+		options: {
+			channel: { type: "string" },
+			agent: { type: "string" },
+			schedule: { type: "string" },
+			prompt: { type: "string" },
+			timezone: { type: "string" },
+			"active-hours": { type: "string" },
+			limit: { type: "string" },
+			json: {
+				type: "boolean",
+				default: false
+			}
+		},
+		allowPositionals: true,
+		strict: false
+	});
+	openDatabase(resolveDbPathFromArgv(argv));
+	try {
+		switch (subcommand) {
+			case "list": {
+				const result = listCronJobs(1, 100);
+				if (values.json) {
+					console.log(JSON.stringify(result.items, null, 2));
+					break;
+				}
+				console.log(`birds (${result.totalItems} total):`);
+				if (result.items.length === 0) {
+					console.log("\n  no birds configured");
+					return;
+				}
+				console.log("");
+				printTable([
+					"uid",
+					"status",
+					"schedule",
+					"agent",
+					"channel",
+					"last",
+					"prompt"
+				], result.items.map((job) => [
+					c("dim", shortUid(job.uid)),
+					job.enabled ? c("green", "enabled") : c("yellow", "disabled"),
+					job.schedule,
+					job.agent_id,
+					job.target_channel_id ?? "-",
+					statusColor(job.last_status),
+					job.prompt.slice(0, 50)
+				]), [
+					void 0,
+					void 0,
+					void 0,
+					void 0,
+					void 0,
+					void 0,
+					50
+				]);
+				break;
+			}
+			case "add": {
+				const schedule = positionals[0];
+				const prompt = positionals.slice(1).join(" ") || values.prompt;
+				if (!schedule || !prompt) {
+					logger.error("usage: browserbird birds add <schedule> <prompt> [--channel <id>] [--agent <id>]");
+					process.exitCode = 1;
+					return;
+				}
+				const activeHoursRaw = values["active-hours"];
+				let activeStart;
+				let activeEnd;
+				if (activeHoursRaw) {
+					const parsed = parseActiveHours(activeHoursRaw);
+					if (!parsed) {
+						logger.error("--active-hours must be HH:MM-HH:MM (e.g. \"09:00-17:00\")");
+						process.exitCode = 1;
+						return;
+					}
+					activeStart = parsed.start;
+					activeEnd = parsed.end;
+				}
+				const job = createCronJob(deriveBirdName(prompt), schedule, prompt, values.channel, values.agent, values.timezone, activeStart, activeEnd);
+				logger.success(`bird ${shortUid(job.uid)} created: "${schedule}"`);
+				process.stderr.write(c("dim", `  hint: run 'browserbird birds fly ${shortUid(job.uid)}' to trigger it now`) + "\n");
+				break;
+			}
+			case "edit": {
+				const uidPrefix = positionals[0];
+				if (!uidPrefix) {
+					logger.error("usage: browserbird birds edit <uid> [--schedule <expr>] [--prompt <text>] [--channel <id>] [--agent <id>] [--timezone <tz>] [--active-hours <range>]");
+					process.exitCode = 1;
+					return;
+				}
+				const bird = resolveBird(uidPrefix);
+				if (!bird) return;
+				const channel = values.channel;
+				const agent = values.agent;
+				const schedule = values.schedule;
+				const prompt = values.prompt;
+				const timezone = values.timezone;
+				const editActiveHoursRaw = values["active-hours"];
+				let editActiveStart;
+				let editActiveEnd;
+				if (editActiveHoursRaw === "") {
+					editActiveStart = null;
+					editActiveEnd = null;
+				} else if (editActiveHoursRaw) {
+					const parsed = parseActiveHours(editActiveHoursRaw);
+					if (!parsed) {
+						logger.error("--active-hours must be HH:MM-HH:MM (e.g. \"09:00-17:00\"), or \"\" to clear");
+						process.exitCode = 1;
+						return;
+					}
+					editActiveStart = parsed.start;
+					editActiveEnd = parsed.end;
+				}
+				if (!schedule && !prompt && !channel && !agent && !timezone && editActiveStart === void 0) {
+					logger.error("provide at least one of: --schedule, --prompt, --channel, --agent, --timezone, --active-hours");
+					process.exitCode = 1;
+					return;
+				}
+				if (updateCronJob(bird.uid, {
+					schedule,
+					prompt,
+					name: prompt ? deriveBirdName(prompt) : void 0,
+					targetChannelId: channel !== void 0 ? channel || null : void 0,
+					agentId: agent,
+					timezone,
+					activeHoursStart: editActiveStart,
+					activeHoursEnd: editActiveEnd
+				})) {
+					logger.success(`bird ${shortUid(bird.uid)} updated`);
+					process.stderr.write(c("dim", `  hint: run 'browserbird birds list' to see updated birds`) + "\n");
+				} else {
+					logger.error(`bird ${shortUid(bird.uid)} not found`);
+					process.exitCode = 1;
+				}
+				break;
+			}
+			case "remove": {
+				const uidPrefix = positionals[0];
+				if (!uidPrefix) {
+					logger.error("usage: browserbird birds remove <uid>");
+					process.exitCode = 1;
+					return;
+				}
+				const bird = resolveBird(uidPrefix);
+				if (!bird) return;
+				if (deleteCronJob(bird.uid)) logger.success(`bird ${shortUid(bird.uid)} removed`);
+				else {
+					logger.error(`bird ${shortUid(bird.uid)} not found`);
+					process.exitCode = 1;
+				}
+				break;
+			}
+			case "enable":
+			case "disable": {
+				const uidPrefix = positionals[0];
+				if (!uidPrefix) {
+					logger.error(`usage: browserbird birds ${subcommand} <uid>`);
+					process.exitCode = 1;
+					return;
+				}
+				const bird = resolveBird(uidPrefix);
+				if (!bird) return;
+				const enabled = subcommand === "enable";
+				if (setCronJobEnabled(bird.uid, enabled)) {
+					logger.success(`bird ${shortUid(bird.uid)} ${enabled ? "enabled" : "disabled"}`);
+					if (enabled) process.stderr.write(c("dim", `  hint: run 'browserbird birds fly ${shortUid(bird.uid)}' to trigger it now`) + "\n");
+				} else {
+					logger.error(`bird ${shortUid(bird.uid)} not found`);
+					process.exitCode = 1;
+				}
+				break;
+			}
+			case "fly": {
+				const uidPrefix = positionals[0];
+				if (!uidPrefix) {
+					logger.error("usage: browserbird birds fly <uid>");
+					process.exitCode = 1;
+					return;
+				}
+				const cronJob = resolveBird(uidPrefix);
+				if (!cronJob) return;
+				const enqueuedJob = enqueue("cron_run", {
+					cronJobUid: cronJob.uid,
+					prompt: cronJob.prompt,
+					channelId: cronJob.target_channel_id,
+					agentId: cronJob.agent_id
+				}, { cronJobUid: cronJob.uid });
+				logger.success(`enqueued job #${enqueuedJob.id} for bird ${shortUid(cronJob.uid)}`);
+				process.stderr.write(c("dim", `  hint: run 'browserbird birds flights ${shortUid(cronJob.uid)}' to check results`) + "\n");
+				break;
+			}
+			case "flights": {
+				const uidPrefix = positionals[0];
+				if (!uidPrefix) {
+					logger.error("usage: browserbird birds flights <uid>");
+					process.exitCode = 1;
+					return;
+				}
+				const bird = resolveBird(uidPrefix);
+				if (!bird) return;
+				const perPage = values.limit != null ? Number(values.limit) : 10;
+				if (!Number.isFinite(perPage) || perPage < 1) {
+					logger.error("--limit must be a positive number");
+					process.exitCode = 1;
+					return;
+				}
+				const result = listFlights(1, perPage, { birdUid: bird.uid });
+				if (values.json) {
+					console.log(JSON.stringify(result.items, null, 2));
+					break;
+				}
+				console.log(`flight history for bird ${shortUid(bird.uid)} (${result.totalItems} total):`);
+				if (result.items.length === 0) {
+					console.log("\n  no flights recorded");
+					return;
+				}
+				console.log("");
+				printTable([
+					"flight",
+					"status",
+					"duration",
+					"started",
+					"error / result"
+				], result.items.map((flight) => {
+					const durationMs = flight.finished_at ? new Date(flight.finished_at).getTime() - new Date(flight.started_at).getTime() : null;
+					const duration = durationMs == null ? "-" : formatDuration(durationMs);
+					return [
+						c("dim", shortUid(flight.uid)),
+						statusColor(flight.status),
+						duration,
+						flight.started_at.slice(0, 19),
+						flight.error ?? flight.result?.slice(0, 60) ?? ""
+					];
+				}), [
+					void 0,
+					void 0,
+					void 0,
+					void 0,
+					60
+				]);
+				break;
+			}
+			default: unknownSubcommand(subcommand, "birds", [
+				"list",
+				"add",
+				"edit",
+				"remove",
+				"enable",
+				"disable",
+				"fly",
+				"flights"
+			]);
+		}
+	} finally {
+		closeDatabase();
+	}
+}
+
+//#endregion
+//#region src/cli/logs.ts
+/** @fileoverview Logs command: show recent log entries from the database. */
+const LOGS_HELP = `
+${c("cyan", "usage:")} browserbird logs [options]
+
+show recent log entries (default: error level).
+
+${c("dim", "options:")}
+
+  ${c("yellow", "--level")} <lvl>    filter by level: error, warn, info (default: error)
+  ${c("yellow", "--limit")} <n>      number of entries to show (default: 20)
+  ${c("yellow", "--json")}           output as JSON
+  ${c("yellow", "--db")} <path>      database file path (env: BROWSERBIRD_DB)
+  ${c("yellow", "--config")} <path>  config file path
+  ${c("yellow", "-h, --help")}       show this help
+`.trim();
+function handleLogs(argv) {
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			level: { type: "string" },
+			limit: { type: "string" },
+			json: {
+				type: "boolean",
+				default: false
+			}
+		},
+		allowPositionals: true,
+		strict: false
+	});
+	const level = values.level;
+	const perPage = values.limit != null ? Number(values.limit) : 20;
+	if (!Number.isFinite(perPage) || perPage < 1) {
+		logger.error("--limit must be a positive number");
+		process.exitCode = 1;
+		return;
+	}
+	openDatabase(resolveDbPathFromArgv(argv));
+	try {
+		const result = getRecentLogs(1, perPage, level ?? "error");
+		if (values.json) {
+			console.log(JSON.stringify(result.items, null, 2));
+			return;
+		}
+		console.log(`logs (${result.totalItems} total, showing ${result.items.length}):`);
+		if (result.items.length === 0) {
+			console.log("\n  no logs recorded");
+			return;
+		}
+		console.log("");
+		printTable([
+			"time",
+			"level",
+			"source",
+			"message"
+		], result.items.map((entry) => [
+			entry.created_at.slice(11, 19),
+			entry.level,
+			entry.source,
+			entry.message
+		]), [
+			void 0,
+			void 0,
+			void 0,
+			80
+		]);
+	} finally {
+		closeDatabase();
+	}
+}
+
+//#endregion
+//#region src/cli/jobs.ts
+/** @fileoverview Jobs command: inspect and manage the job queue. */
+const JOBS_HELP = `
+${c("cyan", "usage:")} browserbird jobs [subcommand] [options]
+
+inspect and manage the job queue.
+
+${c("dim", "subcommands:")}
+
+  ${c("cyan", "list")}             list job queue entries (default)
+  ${c("cyan", "stats")}            show job queue statistics
+  ${c("cyan", "retry")} <id>       retry a failed job (or --all-failed)
+  ${c("cyan", "delete")} <id>      delete a job
+  ${c("cyan", "clear")}            clear completed or failed jobs
+
+${c("dim", "options:")}
+
+  ${c("yellow", "--status")} <s>     filter by status: pending, running, completed, failed (with list)
+  ${c("yellow", "--name")} <s>       filter by job name (with list)
+  ${c("yellow", "--all-failed")}     retry all failed jobs (with retry)
+  ${c("yellow", "--completed")}      clear completed jobs (with clear)
+  ${c("yellow", "--failed")}         clear failed jobs (with clear)
+  ${c("yellow", "--json")}           output as JSON (with list, stats)
+  ${c("yellow", "--db")} <path>      database file path (env: BROWSERBIRD_DB)
+  ${c("yellow", "--config")} <path>  config file path
+  ${c("yellow", "-h, --help")}       show this help
+`.trim();
+function handleJobs(argv) {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		options: {
+			status: { type: "string" },
+			name: { type: "string" },
+			"all-failed": {
+				type: "boolean",
+				default: false
+			},
+			completed: {
+				type: "boolean",
+				default: false
+			},
+			failed: {
+				type: "boolean",
+				default: false
+			},
+			json: {
+				type: "boolean",
+				default: false
+			}
+		},
+		allowPositionals: true,
+		strict: false
+	});
+	const subcommand = positionals[0] ?? "list";
+	openDatabase(resolveDbPathFromArgv(argv));
+	try {
+		switch (subcommand) {
+			case "list": {
+				const result = listJobs(1, 100, {
+					status: values.status,
+					name: values.name
+				});
+				if (values.json) {
+					console.log(JSON.stringify(result.items, null, 2));
+					break;
+				}
+				console.log(`jobs (${result.totalItems} total):`);
+				if (result.items.length === 0) {
+					console.log("\n  no jobs found");
+					return;
+				}
+				console.log("");
+				printTable([
+					"id",
+					"status",
+					"name",
+					"attempts",
+					"created",
+					"error"
+				], result.items.map((job) => [
+					String(job.id),
+					job.status,
+					job.name,
+					`${job.attempts}/${job.max_attempts}`,
+					job.created_at.slice(0, 19),
+					job.error ?? ""
+				]), [
+					void 0,
+					void 0,
+					30,
+					void 0,
+					void 0,
+					40
+				]);
+				break;
+			}
+			case "stats": {
+				const stats = getJobStats();
+				if (values.json) {
+					console.log(JSON.stringify(stats, null, 2));
+					break;
+				}
+				console.log("job queue statistics");
+				console.log("");
+				console.log(`  pending:    ${stats.pending}`);
+				console.log(`  running:    ${stats.running}`);
+				console.log(`  completed:  ${stats.completed}`);
+				console.log(`  failed:     ${stats.failed}`);
+				console.log("              --");
+				console.log(`  total:      ${stats.total}`);
+				break;
+			}
+			case "retry": {
+				if (values["all-failed"]) {
+					const count = retryAllFailedJobs();
+					logger.success(`reset ${count} failed job(s) to pending`);
+					return;
+				}
+				const id = Number(positionals[1]);
+				if (!Number.isFinite(id)) {
+					logger.error("usage: browserbird jobs retry <id> | --all-failed");
+					process.exitCode = 1;
+					return;
+				}
+				if (retryJob(id)) logger.success(`job #${id} reset to pending`);
+				else {
+					logger.error(`job #${id} not found or not in failed state`);
+					process.exitCode = 1;
+				}
+				break;
+			}
+			case "delete": {
+				const id = Number(positionals[1]);
+				if (!Number.isFinite(id)) {
+					logger.error("usage: browserbird jobs delete <id>");
+					process.exitCode = 1;
+					return;
+				}
+				if (deleteJob(id)) logger.success(`job #${id} deleted`);
+				else {
+					logger.error(`job #${id} not found`);
+					process.exitCode = 1;
+				}
+				break;
+			}
+			case "clear": {
+				if (!values.completed && !values.failed) {
+					logger.error("usage: browserbird jobs clear --completed | --failed");
+					process.exitCode = 1;
+					return;
+				}
+				let total = 0;
+				if (values.completed) total += clearJobs("completed");
+				if (values.failed) total += clearJobs("failed");
+				logger.success(`cleared ${total} job(s)`);
+				break;
+			}
+			default: unknownSubcommand(subcommand, "jobs", [
+				"stats",
+				"retry",
+				"delete",
+				"clear"
+			]);
+		}
+	} finally {
+		closeDatabase();
+	}
+}
+
+//#endregion
+//#region src/cli/config.ts
+/** @fileoverview Config command: display merged configuration. */
+const CONFIG_HELP = `
+${c("cyan", "usage:")} browserbird config [options]
+
+view full configuration (defaults merged with browserbird.json).
+
+${c("dim", "options:")}
+
+  ${c("yellow", "--config")} <path>  config file path
+  ${c("yellow", "-h, --help")}       show this help
+`.trim();
+function handleConfig(argv) {
+	const { values } = parseArgs({
+		args: argv,
+		options: { config: { type: "string" } },
+		allowPositionals: false,
+		strict: false
+	});
+	printConfig(values.config);
+}
+function printConfig(configPath) {
+	const config = loadRawConfig(configPath);
+	console.log(c("cyan", "config"));
+	console.log(c("dim", "------"));
+	console.log(`\n${c("dim", "timezone:")} ${config.timezone}`);
+	console.log(`\n${c("cyan", "agents:")}`);
+	for (const a of config.agents) {
+		console.log(`  ${c("cyan", a.id)} (${a.name})`);
+		console.log(`    ${c("dim", "provider:")}  ${a.provider}`);
+		console.log(`    ${c("dim", "model:")}     ${a.model}`);
+		console.log(`    ${c("dim", "max turns:")} ${a.maxTurns}`);
+		console.log(`    ${c("dim", "channels:")}  ${a.channels.join(", ") || "*"}`);
+	}
+	console.log(`\n${c("cyan", "sessions:")}`);
+	console.log(`  ${c("dim", "max concurrent:")}  ${config.sessions.maxConcurrent}`);
+	console.log(`  ${c("dim", "ttl:")}             ${config.sessions.ttlHours}h`);
+	console.log(`  ${c("dim", "timeout:")}         ${config.sessions.processTimeoutMs / 1e3}s`);
+	console.log(`\n${c("cyan", "slack:")}`);
+	console.log(`  ${c("dim", "require mention:")} ${config.slack.requireMention ? "yes" : "no"}`);
+	console.log(`  ${c("dim", "debounce:")}        ${config.slack.coalesce.debounceMs}ms`);
+	console.log(`  ${c("dim", "bypass dms:")}      ${config.slack.coalesce.bypassDms ? "yes" : "no"}`);
+	console.log(`  ${c("dim", "channels:")}        ${config.slack.channels.join(", ") || "(all)"}`);
+	console.log(`  ${c("dim", "quiet hours:")}     ${config.slack.quietHours.enabled ? `${config.slack.quietHours.start}-${config.slack.quietHours.end} (${config.slack.quietHours.timezone})` : "disabled"}`);
+	console.log(`\n${c("cyan", "birds:")}`);
+	console.log(`  ${c("dim", "max attempts:")} ${config.birds.maxAttempts}`);
+	console.log(`\n${c("cyan", "browser:")}`);
+	console.log(`  ${c("dim", "enabled:")}    ${config.browser.enabled ? "yes" : "no"}`);
+	if (config.browser.enabled) {
+		console.log(`  ${c("dim", "mode:")}       ${process.env["BROWSER_MODE"] ?? "persistent"}`);
+		console.log(`  ${c("dim", "vnc port:")}   ${config.browser.vncPort}`);
+		console.log(`  ${c("dim", "novnc port:")} ${config.browser.novncPort}`);
+	}
+	console.log(`\n${c("cyan", "database:")}`);
+	console.log(`  ${c("dim", "retention:")} ${config.database.retentionDays}d`);
+	console.log(`\n${c("cyan", "web:")}`);
+	console.log(`  ${c("dim", "port:")} ${config.web.port}`);
+}
+
+//#endregion
+//#region src/cli/run.ts
+/** @fileoverview CLI entry point: argument parsing and command routing. */
+const MAIN_HELP = BANNER + `
+${c("cyan", "usage:")} browserbird [command] [options]
+
+${c("dim", "commands:")}
+
+  ${c("cyan", "sessions")}    manage sessions
+  ${c("cyan", "birds")}       manage scheduled birds
+  ${c("cyan", "config")}      view configuration
+  ${c("cyan", "logs")}        show recent log entries
+  ${c("cyan", "jobs")}        inspect and manage the job queue
+  ${c("cyan", "doctor")}      check system dependencies
+
+${c("dim", "options:")}
+
+  ${c("yellow", "-h, --help")}     show this help
+  ${c("yellow", "-v, --version")}  show version
+  ${c("yellow", "--verbose")}      enable debug logging
+  ${c("yellow", "--config")}       config file path (env: BROWSERBIRD_CONFIG)
+  ${c("yellow", "--db")}           database file path (env: BROWSERBIRD_DB)
+
+run 'browserbird <command> --help' for command-specific options.`.trimEnd();
+const COMMAND_HELP = {
+	sessions: SESSIONS_HELP,
+	birds: BIRDS_HELP,
+	config: CONFIG_HELP,
+	logs: LOGS_HELP,
+	jobs: JOBS_HELP,
+	doctor: DOCTOR_HELP
+};
+async function run(argv) {
+	const command = argv[0];
+	if (command === "--help" || command === "-h") {
+		console.log(MAIN_HELP);
+		return;
+	}
+	if (!command) {
+		await startDaemon(parseGlobalFlags(argv));
+		return;
+	}
+	if (command === "--version" || command === "-v") {
+		console.log(VERSION);
+		return;
+	}
+	const rest = argv.slice(1);
+	const isHelp = rest.includes("--help") || rest.includes("-h");
+	if (command === "--verbose" || command === "--config" || command === "--no-color") {
+		await startDaemon(parseGlobalFlags(argv));
+		return;
+	}
+	switch (command) {
+		case COMMANDS.SESSIONS:
+			if (isHelp) {
+				console.log(COMMAND_HELP.sessions);
+				return;
+			}
+			handleSessions(rest);
+			break;
+		case COMMANDS.BIRDS:
+			if (isHelp) {
+				console.log(COMMAND_HELP.birds);
+				return;
+			}
+			handleBirds(rest);
+			break;
+		case COMMANDS.CONFIG:
+			if (isHelp) {
+				console.log(COMMAND_HELP.config);
+				return;
+			}
+			handleConfig(rest);
+			break;
+		case COMMANDS.LOGS:
+			if (isHelp) {
+				console.log(COMMAND_HELP.logs);
+				return;
+			}
+			handleLogs(rest);
+			break;
+		case COMMANDS.JOBS:
+			if (isHelp) {
+				console.log(COMMAND_HELP.jobs);
+				return;
+			}
+			handleJobs(rest);
+			break;
+		case COMMANDS.DOCTOR:
+			handleDoctor();
+			break;
+		default: unknownSubcommand(command, "", [
+			"sessions",
+			"birds",
+			"config",
+			"logs",
+			"jobs",
+			"doctor"
+		]);
+	}
+}
+function parseGlobalFlags(argv) {
+	const { values } = parseArgs({
+		args: argv,
+		options: {
+			verbose: {
+				type: "boolean",
+				default: false
+			},
+			config: { type: "string" },
+			db: { type: "string" }
+		},
+		allowPositionals: true,
+		strict: false
+	});
+	if (values.verbose) logger.setLevel("debug");
+	return { flags: {
+		verbose: values.verbose,
+		config: values.config,
+		db: values.db
+	} };
+}
+
+//#endregion
+export { checkDoctor, run };