offsite 0.0.85 → 0.0.87

package/apps/server/dist/main.mjs

@@ -1,21 +1,22 @@
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { accessSync, appendFileSync, chmodSync, closeSync, constants, createReadStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
+import { accessSync, appendFileSync, chmodSync, closeSync, constants, createReadStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync, writeSync } from "node:fs";
 import http, { createServer } from "node:http";
 import path from "node:path";
 import zlib, { createGzip } from "node:zlib";
-import { consola } from "consola";
+import { LogLevels, consola, createConsola } from "consola";
 import { WebSocketServer } from "ws";
 import { z } from "zod";
 import os, { tmpdir } from "node:os";
 import { deleteSession, forkSession, getSessionInfo, getSessionMessages, getSubagentMessages, listSessions, query, renameSession } from "@anthropic-ai/claude-agent-sdk";
+import { formatWithOptions, promisify } from "node:util";
+import { Command } from "@commander-js/extra-typings";
 import { execFile, spawn, spawnSync } from "node:child_process";
 import readline from "node:readline";
-import { Command } from "@commander-js/extra-typings";
 import { lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, rm, rmdir, stat, writeFile } from "node:fs/promises";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { OpenCode, isSessionNotFoundError } from "@opencode/client";
 import { ensure, headers } from "@opencode/client/service";
-import { and, eq, gt, inArray, lte, max, sql } from "drizzle-orm";
+import { and, eq, gt, inArray, isNull, lte, max, sql } from "drizzle-orm";
 import { pathToFileURL } from "node:url";
 import { sumBy } from "es-toolkit";
 import { DatabaseSync } from "node:sqlite";
@@ -23,7 +24,6 @@ import { drizzle } from "drizzle-orm/node-sqlite";
 import { migrate } from "drizzle-orm/node-sqlite/migrator";
 import { integer, real, snakeCase, text } from "drizzle-orm/sqlite-core";
 import sharp from "sharp";
-import { promisify } from "node:util";
 import webPush from "web-push";
 import dns from "node:dns";
 import { BlockList, isIP } from "node:net";
@@ -88,9 +88,73 @@ function publish$2(sessionId, event) {
 function broadcast(event) {
 	for (const client of clients) client.send(event);
 }
+// src/args.ts
+let command = "web";
+let name = null;
+const program = new Command("offsite").description("Starts the server and the web app").option("--host <host>", "Address to listen on", "127.0.0.1").option("--port <port>", "Port to listen on", "47841").option("--dir <dir>", "Folder for settings and accounts", path.join(os.homedir(), ".offsite")).option("--no-auth", "Accept connections without pairing").option("--no-pair", "Don't create a pairing code or print pairing links").option("--pwa", "Serve the web app as an installable app that works offline").option("--connect <addresses>", "Add this machine to the web app with these comma separated addresses; needs --no-auth").configureHelp({ showGlobalOptions: true });
+program.command("web", { isDefault: true }).description("Starts the server and the web app, same as offsite");
+program.command("serve").description("Starts only the server, without the web app").action(() => {
+	command = "serve";
+});
+program.command("pair").description("Creates a pairing code for another browser and prints its link").option("--name <name>", "Name to recognize this browser by").action((options) => {
+	command = "pair";
+	name = options.name ?? null;
+});
+program.command("unpair").description("Picks paired browsers to unpair").action(() => {
+	command = "unpair";
+});
+program.parse();
+const options = program.opts();
+if (!options.auth && !options.pair) program.error("error: --no-pair can't be used with --no-auth");
+if (options.connect !== void 0 && options.auth) program.error("error: --connect needs --no-auth");
+if (options.connect !== void 0 && command === "serve") program.error("error: --connect can't be used with offsite serve");
+const connect$1 = options.connect === void 0 ? null : options.connect.split(",").map((address) => {
+	const url = URL.parse(address);
+	if (url === null || url.protocol !== "http:" && url.protocol !== "https:") return program.error(`error: --connect address ${address} needs http:// or https://, like https://example.com`);
+	return url.origin;
+});
+const args = {
+	...options,
+	dir: path.resolve(options.dir),
+	command,
+	name,
+	connect: connect$1,
+	portGiven: program.getOptionValueSource("port") === "cli"
+};
+const serverDir = path.join(import.meta.dirname, "..");
+// src/lib/log.ts
+const folder$1 = path.join(args.dir, "logs", `${Date.now()}-${process.pid}`);
+const files$1 = /* @__PURE__ */ new Map();
+function write(file, entry) {
+	let descriptor = files$1.get(file);
+	if (descriptor === void 0) {
+		mkdirSync(folder$1, {
+			recursive: true,
+			mode: 448
+		});
+		descriptor = openSync(path.join(folder$1, file), "a", 384);
+		files$1.set(file, descriptor);
+	}
+	const tag = entry.tag === "" ? "" : ` [${entry.tag}]`;
+	const message = formatWithOptions({
+		colors: false,
+		breakLength: Infinity
+	}, ...entry.args);
+	writeSync(descriptor, `${entry.date.toISOString()} ${entry.type.toUpperCase()}${tag} ${message}\n`);
+}
+function fileLogger(file) {
+	return createConsola({
+		level: LogLevels.verbose,
+		throttle: 0,
+		reporters: [{ log: (entry) => write(file, entry) }]
+	});
+}
+const logger = fileLogger("server.log");
+const browserLogger = fileLogger("browser.log");
 // src/services/usage.ts
 const freshFor = 6e4;
 const forcedFreshFor = 1e4;
+const log$20 = logger.withTag("usage");
 const entries = /* @__PURE__ */ new Map();
 const fetching = /* @__PURE__ */ new Map();
 function cachedUsage(accountId) {
@@ -108,6 +172,7 @@ function recordLimits(accountId, limits) {
 		limits: [...current.limits.map((limit) => limits.find((item) => item.window === limit.window) ?? limit), ...limits.filter((item) => !current.limits.some((limit) => limit.window === item.window))],
 		updatedAt: Date.now()
 	});
+	log$20.debug(`account ${accountId} reported ${limits.map((limit) => limit.window).join(", ")} limits from a running session`);
 	broadcast({
 		type: "limits",
 		accountId,
@@ -116,9 +181,15 @@ function recordLimits(accountId, limits) {
 }
 async function readUsage(accountId, force) {
 	const current = cachedUsage(accountId);
-	if (current.fetchedAt !== null && Date.now() - current.fetchedAt < (force ? forcedFreshFor : freshFor)) return current;
+	if (current.fetchedAt !== null && Date.now() - current.fetchedAt < (force ? forcedFreshFor : freshFor)) {
+		log$20.debug(`account ${accountId} served from cache, ${Math.round((Date.now() - current.fetchedAt) / 1e3)}s old${force ? " (forced)" : ""}`);
+		return current;
+	}
 	const pending = fetching.get(accountId);
-	if (pending !== void 0) return pending;
+	if (pending !== void 0) {
+		log$20.debug(`account ${accountId} joined the fetch in progress`);
+		return pending;
+	}
 	const next = fetchUsage(accountId);
 	fetching.set(accountId, next);
 	try {
@@ -134,15 +205,19 @@ async function fetchUsage(accountId) {
 	const account = storedAccounts().find((item) => item.id === accountId);
 	if (account === void 0) throw new Error("That account was removed");
 	let usage;
+	const started = performance.now();
+	log$20.debug(`fetching limits for ${account.name} (${account.provider})`);
 	try {
+		const limits = await providerLimits(account);
+		log$20.debug(`fetched ${limits.length} limits for ${account.name} in ${Math.round(performance.now() - started)}ms`);
 		usage = {
-			limits: await providerLimits(account),
+			limits,
 			fetchedAt: Date.now(),
 			updatedAt: Date.now(),
 			error: null
 		};
 	} catch (error) {
-		console.warn(`could not read usage limits for ${account.name}: ${error}`);
+		log$20.warn(`could not read usage limits for ${account.name}:`, error);
 		usage = {
 			...cachedUsage(accountId),
 			fetchedAt: Date.now(),
@@ -290,44 +365,11 @@ function toBlocks(content, answers) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-// src/args.ts
-let command = "web";
-let name = null;
-const program = new Command("offsite").description("Starts the server and the web app").option("--host <host>", "Address to listen on", "127.0.0.1").option("--port <port>", "Port to listen on", "47841").option("--dir <dir>", "Folder for settings and accounts", path.join(os.homedir(), ".offsite")).option("--no-auth", "Accept connections without pairing").option("--no-pair", "Don't create a pairing code or print pairing links").option("--pwa", "Serve the web app as an installable app that works offline").option("--connect <addresses>", "Add this machine to the web app with these comma separated addresses; needs --no-auth").configureHelp({ showGlobalOptions: true });
-program.command("web", { isDefault: true }).description("Starts the server and the web app, same as offsite");
-program.command("serve").description("Starts only the server, without the web app").action(() => {
-	command = "serve";
-});
-program.command("pair").description("Creates a pairing code for another browser and prints its link").option("--name <name>", "Name to recognize this browser by").action((options) => {
-	command = "pair";
-	name = options.name ?? null;
-});
-program.command("unpair").description("Picks paired browsers to unpair").action(() => {
-	command = "unpair";
-});
-program.parse();
-const options = program.opts();
-if (!options.auth && !options.pair) program.error("error: --no-pair can't be used with --no-auth");
-if (options.connect !== void 0 && options.auth) program.error("error: --connect needs --no-auth");
-if (options.connect !== void 0 && command === "serve") program.error("error: --connect can't be used with offsite serve");
-const connect$1 = options.connect === void 0 ? null : options.connect.split(",").map((address) => {
-	const url = URL.parse(address);
-	if (url === null || url.protocol !== "http:" && url.protocol !== "https:") return program.error(`error: --connect address ${address} needs http:// or https://, like https://example.com`);
-	return url.origin;
-});
-const args = {
-	...options,
-	dir: path.resolve(options.dir),
-	command,
-	name,
-	connect: connect$1,
-	portGiven: program.getOptionValueSource("port") === "cli"
-};
-const serverDir = path.join(import.meta.dirname, "..");
 // src/storage/storage.ts
 const home = args.dir;
 const lockFile = path.join(home, "server.pid");
 const savedServer = z.object({ port: z.number() }).nullable();
+const log$19 = logger.withTag("storage");
 mkdirSync(home, { recursive: true });
 const scratchAvailable = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: home }).status !== 0;
 function listenPort() {
@@ -359,7 +401,8 @@ function lock() {
 	const validPid = Number.isInteger(pid) && pid > 0;
 	const writtenThisBoot = modified > Date.now() - os.uptime() * 1e3;
 	if (validPid && writtenThisBoot && pid !== process.pid && isRunning(pid)) {
-		consola.error(`offsite is already running for ${home} (pid ${pid})`);
+		console.error(`offsite is already running for ${home} (pid ${pid})`);
+		log$19.error(`offsite is already running for ${home} (pid ${pid})`);
 		process.exit(1);
 	}
 	unlinkSync(lockFile);
@@ -392,7 +435,7 @@ function readSettings(name, schema, defaults) {
 	try {
 		value = readJson(name);
 	} catch (error) {
-		console.warn(`invalid ${file}, using the defaults: ${error}`);
+		log$19.warn(`invalid ${file}, using the defaults:`, error);
 		return structuredClone(defaults);
 	}
 	if (value === null) return structuredClone(defaults);
@@ -404,10 +447,10 @@ function readSettings(name, schema, defaults) {
 		for (const target of targets) {
 			const discarded = discard(value, target);
 			if (discarded === null) {
-				console.warn(`invalid ${file}, using the defaults:\n${z.prettifyError(result.error)}`);
+				log$19.warn(`invalid ${file}, using the defaults:\n${z.prettifyError(result.error)}`);
 				return structuredClone(defaults);
 			}
-			console.warn(`${file}: discarded ${discarded.map(String).join(".")} (${issue.message} at ${target.map(String).join(".")})`);
+			log$19.warn(`${file}: discarded ${discarded.map(String).join(".")} (${issue.message} at ${target.map(String).join(".")})`);
 		}
 		result = schema.safeParse(value);
 	}
@@ -475,6 +518,7 @@ function quote(value) {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }
 // src/lib/codex/app-server.ts
+const log$18 = logger.withTag("codex");
 const IDLE_LIMIT$3 = 18e5;
 const START_TIMEOUT = 15e3;
 const REQUEST_TIMEOUT = 3e4;
@@ -515,6 +559,7 @@ var AppServer = class {
 		const executable = findCodex();
 		if (executable === null) throw new Error("Codex is not installed or not on the PATH");
 		this.home = home;
+		log$18.info(`starting the Codex app server for ${home}`);
 		this.child = spawn(executable, ["app-server"], {
 			env: {
 				...process.env,
@@ -541,6 +586,7 @@ var AppServer = class {
 				requestAttestation: false
 			}
 		}, START_TIMEOUT).then(() => this.write({ method: "initialized" }), (error) => {
+			log$18.warn(`the Codex app server for ${home} did not start:`, error);
 			this.child.kill();
 			throw error;
 		});
@@ -549,7 +595,15 @@ var AppServer = class {
 	async request(method, params) {
 		await this.ready;
 		this.armIdleTimer();
-		return await this.call(method, params, REQUEST_TIMEOUT);
+		const started = performance.now();
+		try {
+			const result = await this.call(method, params, REQUEST_TIMEOUT);
+			log$18.debug(`${method} took ${Math.round(performance.now() - started)}ms`);
+			return result;
+		} catch (error) {
+			log$18.debug(`${method} failed after ${Math.round(performance.now() - started)}ms: ${error}`);
+			throw error;
+		}
 	}
 	reply(id, result) {
 		this.write({
@@ -567,6 +621,7 @@ var AppServer = class {
 		});
 	}
 	stop() {
+		log$18.info(`stopping the Codex app server for ${this.home}`);
 		clearTimeout(this.idleTimer);
 		if (servers.get(this.home) === this) servers.delete(this.home);
 		this.child.stdin.end();
@@ -607,7 +662,7 @@ var AppServer = class {
 		try {
 			message = JSON.parse(line);
 		} catch {
-			console.warn(`ignoring a Codex line that is not JSON: ${line}`);
+			log$18.warn(`ignoring a Codex line that is not JSON: ${line}`);
 			return;
 		}
 		if (message.method === void 0) {
@@ -657,6 +712,7 @@ var AppServer = class {
 	exit(error) {
 		if (this.exited !== null) return;
 		this.exited = error;
+		log$18.info(`the Codex app server for ${this.home} exited:`, error.message);
 		clearTimeout(this.idleTimer);
 		if (servers.get(this.home) === this) servers.delete(this.home);
 		for (const waiter of this.waiting.values()) waiter.reject(error);
@@ -666,6 +722,7 @@ var AppServer = class {
 	}
 };
 // src/lib/codex/accounts.ts
+const log$17 = logger.withTag("codex");
 const privateEntries = [
 	"auth.json",
 	"models_cache.json",
@@ -682,6 +739,7 @@ async function codexAccount(account) {
 		email: null,
 		displayName: null,
 		organization: null,
+		identity: null,
 		plan: null,
 		linked
 	};
@@ -696,7 +754,7 @@ async function codexAccount(account) {
 			case "chatgpt": return {
 				...base,
 				email: result.account.email,
-				displayName: codexDisplayName(configDir),
+				...codexLogin(configDir),
 				organization: result.account.workspaceName,
 				plan: result.account.planType,
 				error: null,
@@ -768,21 +826,40 @@ function toLimits(snapshot) {
 		rejected: window.usedPercent >= 100
 	}]);
 }
-function codexDisplayName(home) {
+function codexLogin(home) {
 	let raw;
 	try {
 		raw = JSON.parse(readFileSync(path.join(home, "auth.json"), "utf8"));
 	} catch (error) {
-		if (error.code !== "ENOENT") console.warn(`could not read the Codex account name: ${error}`);
-		return null;
+		if (error.code !== "ENOENT") log$17.warn(`could not read the Codex account:`, error);
+		return {
+			displayName: null,
+			identity: null
+		};
 	}
-	if (!isRecord(raw) || !isRecord(raw.tokens) || typeof raw.tokens.id_token !== "string") return null;
+	if (!isRecord(raw) || !isRecord(raw.tokens) || typeof raw.tokens.id_token !== "string") return {
+		displayName: null,
+		identity: null
+	};
 	const payload = raw.tokens.id_token.split(".").at(1);
-	if (payload === void 0) return null;
+	if (payload === void 0) return {
+		displayName: null,
+		identity: null
+	};
 	const claims = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-	if (!isRecord(claims) || typeof claims.name !== "string") return null;
-	const name = claims.name.trim();
-	return name === "" ? null : name;
+	if (!isRecord(claims)) return {
+		displayName: null,
+		identity: null
+	};
+	const name = typeof claims.name === "string" ? claims.name.trim() : "";
+	const auth = claims["https://api.openai.com/auth"];
+	return {
+		displayName: name === "" ? null : name,
+		identity: isRecord(auth) && typeof auth.chatgpt_user_id === "string" && typeof auth.chatgpt_account_id === "string" ? {
+			accountId: auth.chatgpt_user_id,
+			organizationId: auth.chatgpt_account_id
+		} : null
+	};
 }
 function isMirror(dir) {
 	try {
@@ -1069,19 +1146,6 @@ const configSchema = z.strictObject({
 		codex: z.boolean().default(true),
 		opencode: z.boolean().default(true)
 	}).prefault({}),
-	newThreads: z.strictObject({
-		provider: z.enum([
-			"claude",
-			"codex",
-			"opencode"
-		]).default("claude"),
-		accountId: z.string().nullable().default(null),
-		models: z.strictObject({
-			claude: z.string().nullable().default(null),
-			codex: z.string().nullable().default(null),
-			opencode: z.string().nullable().default(null)
-		}).prefault({})
-	}).prefault({}),
 	commitMessage: generationModel,
 	titleGeneration: generationModel,
 	models: z.strictObject({
@@ -1091,7 +1155,11 @@ const configSchema = z.strictObject({
 	}).prefault({}),
 	delivery: z.enum(["queue", "steer"]).default("steer"),
 	autoSkipQuestionTimeout: z.number().positive().nullable().default(180),
-	autoPermissionMode: z.enum(["allow", "deny"]).default("allow"),
+	autoPermissionMode: z.enum([
+		"bypass",
+		"allow",
+		"deny"
+	]).default("bypass"),
 	autoPermissionTimeout: z.number().positive().nullable().default(15),
 	terminal: z.strictObject({
 		shell: z.strictObject({
@@ -1153,8 +1221,10 @@ function saveConfig(value) {
 	return result.data;
 }
 // src/lib/live.ts
+const log$16 = logger.withTag("runs");
 const runs = /* @__PURE__ */ new Map();
 const titleJobs = /* @__PURE__ */ new Set();
+let states = /* @__PURE__ */ new Map();
 function activity() {
 	const result = {};
 	for (const run of runs.values()) result[run.sessionId] = {
@@ -1170,6 +1240,19 @@ function activity() {
 	return result;
 }
 function broadcastActivity() {
+	const next = /* @__PURE__ */ new Map();
+	for (const run of runs.values()) {
+		const state = [
+			run.running ? "running" : "idle",
+			...run.pending.size > 0 ? ["waiting for an answer"] : [],
+			...run.compacting ? ["compacting"] : []
+		].join(", ");
+		next.set(run.sessionId, state);
+		if (!states.has(run.sessionId)) log$16.info(`${run.provider} session ${run.sessionId} opened in ${run.cwd} with account ${run.settings.accountId}`);
+		if (states.get(run.sessionId) !== state) log$16.debug(`session ${run.sessionId} is ${state}`);
+	}
+	for (const sessionId of states.keys()) if (!next.has(sessionId)) log$16.info(`session ${sessionId} closed`);
+	states = next;
 	broadcast({
 		type: "activity",
 		activity: activity()
@@ -1178,16 +1261,18 @@ function broadcastActivity() {
 function scheduleAutoResolve(sessionId, request) {
 	if (request.kind === "plan") return request;
 	const config = readConfig();
-	const seconds = request.kind === "question" ? config.autoSkipQuestionTimeout : config.autoPermissionTimeout;
+	const run = runs.get(sessionId);
+	const immediate = config.autoPermissionMode === "bypass" && (run?.provider === "claude" && run.settings.mode === "bypassPermissions" || run?.provider === "codex" && run.settings.mode === "full-access");
+	const seconds = request.kind === "question" ? config.autoSkipQuestionTimeout : immediate ? 0 : config.autoPermissionTimeout;
 	if (seconds === null) return request;
-	const decision = request.kind === "question" ? "allow" : config.autoPermissionMode;
+	const decision = request.kind === "question" || config.autoPermissionMode === "bypass" ? "allow" : config.autoPermissionMode;
 	setTimeout(async () => {
 		const run = runs.get(sessionId);
 		if (run === void 0) return;
 		try {
 			await run.respond(request.id, decision, request.kind === "question" ? {} : null);
 		} catch (error) {
-			console.warn(`could not auto-resolve ${request.id}: ${error}`);
+			log$16.warn(`could not auto-resolve ${request.id}:`, error);
 		}
 	}, seconds * 1e3);
 	return {
@@ -1328,6 +1413,7 @@ function reply(method, params, decision, answers) {
 	throw new Error(`offsite cannot answer ${method}`);
 }
 // src/lib/codex/run.ts
+const log$15 = logger.withTag("codex");
 const IDLE_LIMIT$2 = 18e5;
 function codexServer(settings) {
 	return appServer(storedAccount("codex", settings.accountId).configDir ?? codexBaseDir);
@@ -1452,9 +1538,10 @@ var CodexRun = class CodexRun {
 		if (runs.get(this.sessionId) === this) runs.delete(this.sessionId);
 		this.server.threads.delete(this.sessionId);
 		clearTimeout(this.idleTimer);
-		this.server.request("thread/unsubscribe", { threadId: this.sessionId }).catch((error) => console.warn(`could not unload Codex thread: ${error}`)).finally(() => this.end());
+		this.server.request("thread/unsubscribe", { threadId: this.sessionId }).catch((error) => log$15.warn(`could not unload Codex thread:`, error)).finally(() => this.end());
 	}
 	exited() {
+		log$15.warn(`session ${this.sessionId} lost its Codex app server`);
 		this.put(errorItem(randomUUID(), this.pending.size === 0 ? "Codex stopped" : "Codex stopped, its open requests expired"));
 		if (runs.get(this.sessionId) === this) runs.delete(this.sessionId);
 		this.end();
@@ -1658,6 +1745,7 @@ var CodexRun = class CodexRun {
 		});
 	}
 	fail(error) {
+		log$15.warn(`session ${this.sessionId} failed:`, error);
 		this.put(errorItem(randomUUID(), error instanceof Error ? error.message : String(error)));
 	}
 	armIdleTimer() {
@@ -2524,6 +2612,7 @@ function sessionSettings(session, settings) {
 	};
 }
 // src/lib/opencode/run.ts
+const log$14 = logger.withTag("opencode");
 const IDLE_LIMIT$1 = 18e5;
 const RECENT = 30;
 const replies = {
@@ -2651,6 +2740,7 @@ var OpenCodeRun = class OpenCodeRun {
 		this.end();
 	}
 	exited() {
+		log$14.warn(`session ${this.sessionId} lost the connection to OpenCode`);
 		this.put([errorItem(randomUUID(), this.pending.size === 0 ? "Lost the connection to OpenCode" : "Lost the connection to OpenCode, its open requests expired")]);
 		this.stop();
 	}
@@ -2718,7 +2808,7 @@ var OpenCodeRun = class OpenCodeRun {
 	}
 	refresh(client) {
 		clearTimeout(this.refreshTimer);
-		this.loading = this.loading.then(async () => this.load(client ?? await openCode())).catch((error) => console.warn(`could not load OpenCode messages: ${error}`));
+		this.loading = this.loading.then(async () => this.load(client ?? await openCode())).catch((error) => log$14.warn(`could not load OpenCode messages:`, error));
 	}
 	async load(client) {
 		const messages = (await client.message.list({
@@ -2835,6 +2925,7 @@ var OpenCodeRun = class OpenCodeRun {
 		});
 	}
 	fail(error) {
+		log$14.warn(`session ${this.sessionId} failed:`, error);
 		this.put([errorItem(randomUUID(), error instanceof Error ? error.message : String(error))]);
 	}
 	armIdleTimer() {
@@ -2885,6 +2976,11 @@ const projects$1 = snakeCase.table("projects", {
 });
 const sessions$1 = snakeCase.table("sessions", {
 	sessionId: text().primaryKey(),
+	provider: text({ enum: [
+		"claude",
+		"codex",
+		"opencode"
+	] }),
 	interactedAt: integer(),
 	status: text({ enum: [
 		"active",
@@ -2920,6 +3016,16 @@ const pushSubscriptions = snakeCase.table("push_subscriptions", {
 	machine: text().notNull(),
 	server: text().notNull()
 });
+const lastUsedModels = snakeCase.table("last_used_models", {
+	provider: text({ enum: [
+		"claude",
+		"codex",
+		"opencode"
+	] }).primaryKey(),
+	accountId: text(),
+	model: text().notNull(),
+	usedAt: integer().notNull()
+});
 // src/storage/auth.ts
 const CODE_LIFETIME = 3e5;
 const DEVICE_LIFETIME = 2592e6;
@@ -3969,10 +4075,145 @@ async function find(provider, paths) {
 			});
 	}
 }
+// src/services/threads.ts
+const log$13 = logger.withTag("threads");
+const allProviders$2 = [
+	"claude",
+	"codex",
+	"opencode"
+];
+const threads = {
+	claude: /* @__PURE__ */ new Map(),
+	codex: /* @__PURE__ */ new Map(),
+	opencode: /* @__PURE__ */ new Map()
+};
+const changed = {
+	claude: /* @__PURE__ */ new Set(),
+	codex: /* @__PURE__ */ new Set(),
+	opencode: /* @__PURE__ */ new Set()
+};
+const failures = /* @__PURE__ */ new Set();
+let built = Promise.resolve();
+let builtFor = "";
+function rebuildThreads() {
+	const config = readConfig();
+	const key = JSON.stringify([
+		projectPaths$1(),
+		config.enabledProviders,
+		config.claudeBaseDir
+	]);
+	if (key === builtFor) return;
+	builtFor = key;
+	built = relistAll();
+}
+function threadsReady() {
+	return built;
+}
+function threadFailed(provider) {
+	return failures.has(provider);
+}
+function knownThreads() {
+	const known = new Set(projects().map((project) => project.id));
+	return allProviders$2.filter((provider) => readConfig().enabledProviders[provider]).flatMap((provider) => [...threads[provider].values()]).filter((item) => known.has(item.projectId));
+}
+async function providerThreads(provider) {
+	await built;
+	if (failures.has(provider)) throw new Error(`could not list ${providerName(provider)} sessions`);
+	return knownThreads().filter((item) => item.provider === provider);
+}
+function threadOf(provider, id) {
+	return threads[provider].get(id);
+}
+function threadProvider(id) {
+	return allProviders$2.find((provider) => threads[provider].has(id));
+}
+function markChanged(provider, id) {
+	changed[provider].add(id);
+}
+function fileChanged(provider, filename) {
+	if (filename === null) return;
+	if (provider === "claude") {
+		const parts = filename.split(path.sep);
+		if (parts.length === 2 && parts[1].endsWith(".jsonl")) changed.claude.add(path.basename(parts[1], ".jsonl"));
+		return;
+	}
+	const id = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/.exec(filename)?.[1];
+	if (id !== void 0) changed.codex.add(id);
+}
+function forgetThread(provider, id) {
+	threads[provider].delete(id);
+	broadcast({ type: "threads" });
+}
+async function updateThreads(provider) {
+	if (provider === "opencode") {
+		await relist(provider);
+		return;
+	}
+	const ids = [...changed[provider]];
+	changed[provider].clear();
+	if (ids.length === 0) return;
+	await built;
+	const paths = new Map(projectPaths$1());
+	const results = await Promise.all(ids.map(async (id) => {
+		try {
+			return {
+				id,
+				item: await timeLimit(lookup$1(provider, id, paths), `${providerName(provider)} did not find session ${id} in time`)
+			};
+		} catch (error) {
+			log$13.warn(`could not update ${providerName(provider)} session:`, error);
+			return null;
+		}
+	}));
+	let updated = false;
+	for (const result of results) {
+		if (result === null) continue;
+		const before = threads[provider].get(result.id);
+		if (result.item === null) {
+			updated ||= before !== void 0;
+			threads[provider].delete(result.id);
+			continue;
+		}
+		updated ||= JSON.stringify(before) !== JSON.stringify(result.item);
+		threads[provider].set(result.id, result.item);
+	}
+	if (updated) broadcast({ type: "threads" });
+}
+async function lookup$1(provider, id, paths) {
+	const known = threads[provider].get(id);
+	const knownPath = known === void 0 ? void 0 : [...paths].find((entry) => entry[1] === known.projectId);
+	if (knownPath === void 0) return info(provider, id, paths);
+	return await info(provider, id, new Map([knownPath])) ?? info(provider, id, paths);
+}
+async function relistAll() {
+	await Promise.all(allProviders$2.map((provider) => relist(provider)));
+}
+async function relist(provider) {
+	if (!readConfig().enabledProviders[provider]) {
+		threads[provider] = /* @__PURE__ */ new Map();
+		failures.delete(provider);
+		broadcast({ type: "threads" });
+		return;
+	}
+	try {
+		const found = await timeLimit(find(provider, new Map(projectPaths$1())), `${providerName(provider)} did not list its sessions in time`) ?? [];
+		threads[provider] = new Map(found.map((item) => [item.id, item]));
+		failures.delete(provider);
+	} catch (error) {
+		log$13.warn(`could not list all ${providerName(provider)} sessions:`, error);
+		failures.add(provider);
+		builtFor = "";
+	}
+	broadcast({ type: "threads" });
+}
+function projectPaths$1() {
+	return projects().map((project) => [project.path, project.id]);
+}
 // src/services/sessions.ts
+const log$12 = logger.withTag("sessions");
 const day = 864e5;
 const REFRESH_DELAY = 1e3;
-const allProviders = [
+const allProviders$1 = [
 	"claude",
 	"codex",
 	"opencode"
@@ -4005,61 +4246,35 @@ const providers = /* @__PURE__ */ new Map();
 let watchers = [];
 function sessions() {
 	const known = new Set(projects().map((project) => project.id));
-	return withStatus(allProviders.flatMap((provider) => listed[provider]).filter((item) => known.has(item.projectId))).filter((session) => session.status !== "inactive");
+	return withStatus(allProviders$1.flatMap((provider) => listed[provider]).filter((item) => known.has(item.projectId))).filter((session) => session.status !== "inactive");
 }
-async function inactiveSessions(projectId) {
-	return (await everything(projects().filter((project) => projectId === null || project.id === projectId || projectId === "no-project" && project.scratch).map((project) => [project.path, project.id]))).filter((session) => session.status === "inactive").sort((a, b) => b.updatedAt - a.updatedAt);
+async function inactiveSessions(params) {
+	await threadsReady();
+	const scope = new Set(projects().filter((project) => params.projectId === null || project.id === params.projectId || params.projectId === "no-project" && project.scratch).map((project) => project.id));
+	const found = withStatus(knownThreads().filter((item) => scope.has(item.projectId))).filter((session) => session.status === "inactive").sort((a, b) => b.updatedAt - a.updatedAt);
+	return {
+		sessions: found.slice(0, params.limit),
+		total: found.length
+	};
 }
 async function searchableSessions() {
-	const paths = projectPaths();
-	const lists = await Promise.all(enabledProviders().map(async (provider) => {
-		try {
-			return {
-				provider,
-				items: await timeLimit(find(provider, new Map(paths)), `${providerName(provider)} did not list its sessions in time`) ?? [],
-				failed: false
-			};
-		} catch (error) {
-			console.warn(`could not search ${providerName(provider)}: ${error}`);
-			return {
-				provider,
-				items: [],
-				failed: true
-			};
-		}
-	}));
-	const found = lists.flatMap((list) => list.items);
-	for (const item of found) providers.set(item.id, item.provider);
+	await threadsReady();
+	const found = knownThreads();
 	const opens = new Map(db.select().from(sessionOpens).all().map((record) => [record.sessionId, record]));
 	return {
 		sessions: withStatus(found).map((session) => ({
 			...session,
 			opens: opens.get(session.id) ?? null
 		})),
-		failed: lists.filter((list) => list.failed).map((list) => list.provider)
+		failed: enabledProviders().filter((provider) => threadFailed(provider))
 	};
 }
 async function findSession(id) {
-	const paths = new Map(projectPaths());
+	if (ownerOf(id) === void 0) await threadsReady();
 	const owner = ownerOf(id);
-	if (owner !== void 0) {
-		const item = await info(owner, id, paths);
-		return item === null ? null : withStatus([item])[0];
-	}
-	for (const provider of allProviders) {
-		if (!readConfig().enabledProviders[provider]) continue;
-		const item = await info(provider, id, paths).catch(() => null);
-		if (item !== null) {
-			providers.set(id, provider);
-			return withStatus([item])[0];
-		}
-	}
-	return null;
-}
-async function everything(paths) {
-	const found = (await Promise.all(enabledProviders().map((provider) => find(provider, new Map(paths))))).flatMap((items) => items ?? []);
-	for (const item of found) providers.set(item.id, item.provider);
-	return withStatus(found);
+	if (owner === void 0) return null;
+	const item = await info(owner, id, new Map(projectPaths()));
+	return item === null ? null : withStatus([item])[0];
 }
 function withStatus(items) {
 	const records = new Map(db.select().from(sessions$1).all().map((record) => [record.sessionId, record]));
@@ -4074,16 +4289,16 @@ function withStatus(items) {
 	});
 }
 function enabledProviders() {
-	return allProviders.filter((provider) => readConfig().enabledProviders[provider]);
+	return allProviders$1.filter((provider) => readConfig().enabledProviders[provider]);
 }
 function projectPaths() {
 	return projects().map((project) => [project.path, project.id]);
 }
 function ownerOf(sessionId) {
-	return runs.get(sessionId)?.provider ?? providers.get(sessionId);
+	return runs.get(sessionId)?.provider ?? db.select({ provider: sessions$1.provider }).from(sessions$1).where(eq(sessions$1.sessionId, sessionId)).get()?.provider ?? providers.get(sessionId) ?? threadProvider(sessionId);
 }
 function providerStatuses() {
-	return allProviders.map((provider) => statuses[provider]);
+	return allProviders$1.map((provider) => statuses[provider]);
 }
 function listedUpdatedAt(provider, sessionId) {
 	return listed[provider].find((item) => item.id === sessionId)?.updatedAt ?? null;
@@ -4093,14 +4308,16 @@ function providerOf(sessionId) {
 	if (provider === void 0) throw new Error("offsite does not know this session yet, reload the page");
 	return provider;
 }
-function recordInteraction(id) {
+function recordInteraction(id, provider) {
 	db.insert(sessions$1).values({
 		sessionId: id,
+		provider,
 		interactedAt: Date.now(),
 		status: "active"
 	}).onConflictDoUpdate({
 		target: sessions$1.sessionId,
 		set: {
+			provider,
 			interactedAt: Date.now(),
 			status: sql`CASE ${sessions$1.status} WHEN 'pinned' THEN 'pinned' WHEN 'snoozed' THEN 'snoozed' WHEN 'minimized' THEN 'minimized' ELSE 'active' END`
 		}
@@ -4123,13 +4340,15 @@ function publishSessions() {
 	});
 }
 function refreshAll() {
-	for (const provider of allProviders) refresh(provider);
+	rebuildThreads();
+	for (const provider of allProviders$1) refresh(provider);
 }
 function refreshSessions(provider) {
 	if (timers.has(provider)) return;
 	timers.set(provider, setTimeout(() => {
 		timers.delete(provider);
 		refresh(provider);
+		updateThreads(provider);
 	}, REFRESH_DELAY));
 }
 async function refresh(provider) {
@@ -4178,7 +4397,7 @@ async function list(provider) {
 		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		console.warn(`could not list ${providerName(provider)} sessions: ${message}`);
+		log$12.warn(`could not list ${providerName(provider)} sessions: ${message}`);
 		statuses[provider] = {
 			provider,
 			state: "error",
@@ -4194,15 +4413,10 @@ async function list(provider) {
 }
 async function tracked(provider, paths) {
 	if (provider === "codex" && !codexInstalled() || provider === "opencode" && !openCodeInstalled()) return null;
-	return (await Promise.all(db.select().from(sessions$1).all().map((record) => {
-		const owner = ownerOf(record.sessionId);
-		if (owner === provider) return lookup(provider, record.sessionId, paths);
-		if (owner === void 0) return lookup(provider, record.sessionId, paths).catch(() => null);
-		return null;
-	}))).filter((item) => item !== null);
+	return (await Promise.all(db.select().from(sessions$1).all().filter((record) => record.provider === provider).map((record) => lookup(provider, record.sessionId, paths)))).filter((item) => item !== null);
 }
 async function lookup(provider, sessionId, paths) {
-	const known = listed[provider].find((item) => item.id === sessionId);
+	const known = threadOf(provider, sessionId) ?? listed[provider].find((item) => item.id === sessionId);
 	const knownPath = known === void 0 ? void 0 : [...paths].find((entry) => entry[1] === known.projectId);
 	if (knownPath === void 0) return info(provider, sessionId, paths);
 	return await info(provider, sessionId, new Map([knownPath])) ?? info(provider, sessionId, paths);
@@ -4212,11 +4426,16 @@ function watchSessions() {
 	watchers = [["claude", path.join(claudeBaseDir(), "projects")], ["codex", path.join(codexBaseDir, "sessions")]].flatMap(([provider, dir]) => {
 		if (!readConfig().enabledProviders[provider]) return [];
 		try {
-			const watcher = watch(dir, { recursive: true }, () => refreshSessions(provider));
-			watcher.on("error", (error) => console.warn(`stopped watching ${dir}: ${error}`));
+			const watcher = watch(dir, { recursive: true }, (_, filename) => {
+				fileChanged(provider, filename);
+				refreshSessions(provider);
+			});
+			watcher.on("error", (error) => log$12.warn(`stopped watching ${dir}:`, error));
+			log$12.debug(`watching ${dir}`);
 			return [watcher];
 		} catch (error) {
 			if (error.code !== "ENOENT") throw error;
+			log$12.debug(`not watching ${dir}, it does not exist`);
 			return [];
 		}
 	});
@@ -4250,16 +4469,24 @@ async function updateSession(id, patch) {
 			status: patch.status,
 			interactedAt: Date.now()
 		} : { status: patch.status };
+		const provider = providerOf(id);
 		db.insert(sessions$1).values({
 			sessionId: id,
+			provider,
 			...set
 		}).onConflictDoUpdate({
 			target: sessions$1.sessionId,
-			set
+			set: {
+				provider,
+				...set
+			}
 		}).run();
-		await refresh(providerOf(id));
+		await refresh(provider);
+	}
+	if (patch.title !== void 0) {
+		markChanged(providerOf(id), id);
+		refreshSessions(providerOf(id));
 	}
-	if (patch.title !== void 0) refreshSessions(providerOf(id));
 }
 async function removeSession(id, projectId) {
 	const provider = providerOf(id);
@@ -4280,19 +4507,19 @@ async function removeSession(id, projectId) {
 	db.delete(sessions$1).where(eq(sessions$1.sessionId, id)).run();
 	db.delete(sessionOpens).where(eq(sessionOpens.sessionId, id)).run();
 	listed[provider] = listed[provider].filter((item) => item.id !== id);
+	forgetThread(provider, id);
 	const project = projects().find((item) => item.id === projectId);
 	if (project === void 0 || !project.scratch) return;
-	try {
-		if ((await everything([[project.path, project.id]])).filter((item) => item.id !== id).length === 0) removeProject(project.id);
-	} catch (error) {
-		console.warn(`could not check other chats in ${project.path}: ${error}`);
-	}
+	await threadsReady();
+	if (enabledProviders().some((owner) => threadFailed(owner))) return;
+	if (!knownThreads().some((item) => item.projectId === project.id)) removeProject(project.id);
 }
 async function fork(sessionId, projectId, messageId) {
 	const provider = providerOf(sessionId);
 	const result = await forkWith(provider, sessionId, projectPath(projectId), messageId);
 	providers.set(result.sessionId, provider);
-	recordInteraction(result.sessionId);
+	recordInteraction(result.sessionId, provider);
+	markChanged(provider, result.sessionId);
 	refreshSessions(provider);
 	return result;
 }
@@ -4306,6 +4533,7 @@ async function forkWith(provider, sessionId, cwd, messageId) {
 	})).sessionId };
 }
 // src/lib/opencode/client.ts
+const log$11 = logger.withTag("opencode");
 const listChanges = /* @__PURE__ */ new Set([
 	"session.created",
 	"session.renamed",
@@ -4351,6 +4579,7 @@ async function start() {
 }
 async function connect() {
 	const endpoint = await ensure();
+	log$11.info(`connected to OpenCode at ${endpoint.url}`);
 	return OpenCode.make({
 		baseUrl: endpoint.url,
 		headers: headers(endpoint)
@@ -4365,10 +4594,11 @@ async function listen(client) {
 			signal: controller.signal,
 			onActivity: () => silence.refresh()
 		})) route(event);
-		console.warn("the OpenCode event stream ended");
+		log$11.warn("the OpenCode event stream ended");
 	} catch (error) {
 		if (listener !== controller) return;
-		console.warn(controller.signal.aborted ? `the OpenCode event stream was silent for ${SILENCE_LIMIT$2 / 1e3} seconds` : `lost the OpenCode event stream: ${error}`);
+		if (controller.signal.aborted) log$11.warn(`the OpenCode event stream was silent for ${SILENCE_LIMIT$2 / 1e3} seconds`);
+		else log$11.warn("lost the OpenCode event stream:", error);
 	} finally {
 		clearTimeout(silence);
 	}
@@ -4384,14 +4614,15 @@ async function reconnect() {
 		try {
 			client = await connect();
 		} catch (error) {
+			log$11.debug(`reconnect attempt ${attempt + 1} to OpenCode failed:`, error);
 			failure = error;
 			continue;
 		}
 		listen(client);
-		await catchUp(client).catch((error) => console.warn(`could not catch up with OpenCode: ${error}`));
+		await catchUp(client).catch((error) => log$11.warn(`could not catch up with OpenCode:`, error));
 		return client;
 	}
-	console.warn(`could not reconnect to OpenCode: ${failure}`);
+	log$11.warn(`could not reconnect to OpenCode:`, failure);
 	connection = void 0;
 	for (const run of openCodeRuns()) run.exited();
 	refreshSessions("opencode");
@@ -4422,6 +4653,7 @@ function openCodeRuns() {
 	return [...runs.values()].flatMap((run) => run.provider === "opencode" ? [run] : []);
 }
 // src/services/accounts.ts
+const log$10 = logger.withTag("accounts");
 const providerNames = {
 	claude: "Claude",
 	codex: "Codex",
@@ -4489,6 +4721,7 @@ function disabledAccount(account) {
 		email: null,
 		displayName: null,
 		organization: null,
+		identity: null,
 		plan: null,
 		error: null,
 		linked: true,
@@ -4502,7 +4735,7 @@ async function publishAccounts() {
 			...await accounts()
 		});
 	} catch (error) {
-		console.warn(`could not list accounts: ${error}`);
+		log$10.warn(`could not list accounts:`, error);
 	}
 }
 async function capabilities(provider, accountId, cwd) {
@@ -4609,6 +4842,7 @@ function validAccount(name, configDir) {
 	throw new Error("Use an absolute config directory or one starting with ~/");
 }
 // src/services/push.ts
+const log$9 = logger.withTag("push");
 const TITLE_LIMIT = 100;
 const BODY_LIMIT = 500;
 const TIME_TO_LIVE = 900;
@@ -4656,12 +4890,12 @@ function subscribe(registration, client) {
 		set: values
 	}).run();
 	if (notifier !== null && notifier.client === client) notifier.endpoint = registration.subscription.endpoint;
-	console.log("a browser subscribed to push notifications");
+	log$9.info("a browser subscribed to push notifications");
 }
 function unsubscribe(endpoint) {
 	db.delete(pushSubscriptions).where(eq(pushSubscriptions.endpoint, endpoint)).run();
 	if (notifier !== null && notifier.endpoint === endpoint) notifier.endpoint = null;
-	console.log("a browser unsubscribed from push notifications");
+	log$9.info("a browser unsubscribed from push notifications");
 }
 async function sendPush(message) {
 	const subscriptions = targets();
@@ -4672,7 +4906,7 @@ async function sendPush(message) {
 		body: [...message.body].slice(0, BODY_LIMIT).join("")
 	};
 	const gone = [];
-	let sent = false;
+	let delivered = 0;
 	await Promise.all(subscriptions.map(async (subscription) => {
 		try {
 			await webPush.sendNotification({
@@ -4694,7 +4928,7 @@ async function sendPush(message) {
 				urgency: "high",
 				timeout: SEND_TIMEOUT
 			});
-			sent = true;
+			delivered += 1;
 		} catch (error) {
 			const status = error.statusCode;
 			if (status !== void 0 && [
@@ -4703,22 +4937,24 @@ async function sendPush(message) {
 				404,
 				410
 			].includes(status)) {
-				console.log(`push subscription ${subscription.endpoint} is gone or was made for another key, removing it`);
+				log$9.info(`push subscription ${subscription.endpoint} is gone or was made for another key, removing it`);
 				gone.push(subscription.endpoint);
 				return;
 			}
-			console.warn(`could not send a push to ${subscription.endpoint}: ${error}`);
+			log$9.warn(`could not send a push to ${subscription.endpoint}:`, error);
 		}
 	}));
-	if (gone.length === 0) return sent;
+	log$9.debug(`sent a push to ${delivered} of ${subscriptions.length} browsers`);
+	if (gone.length === 0) return delivered > 0;
 	db.delete(pushSubscriptions).where(and(eq(pushSubscriptions.server, server$1), inArray(pushSubscriptions.endpoint, gone))).run();
-	return sent;
+	return delivered > 0;
 }
 function targets() {
 	if (notifier === null || notifier.endpoint === null) return [];
 	return db.select().from(pushSubscriptions).where(and(eq(pushSubscriptions.server, server$1), eq(pushSubscriptions.endpoint, notifier.endpoint))).all();
 }
 // src/lib/claude/claude.ts
+const log$8 = logger.withTag("claude");
 const efforts = [
 	"low",
 	"medium",
@@ -4857,7 +5093,7 @@ async function claudeAccount(account) {
 		return {
 			...account,
 			email: info.email ?? null,
-			displayName: claudeDisplayName(configDir),
+			...claudeLogin(configDir),
 			organization: info.organization ?? null,
 			plan: info.subscriptionType ?? null,
 			error: null,
@@ -4870,6 +5106,7 @@ async function claudeAccount(account) {
 			email: null,
 			displayName: null,
 			organization: null,
+			identity: null,
 			plan: null,
 			error: error instanceof Error ? error.message : String(error),
 			linked,
@@ -4948,18 +5185,31 @@ async function claudeLimits(account) {
 		probe.close();
 	}
 }
-function claudeDisplayName(configDir) {
+function claudeLogin(configDir) {
 	const file = path.resolve(configDir) === path.join(os.homedir(), ".claude") ? path.join(os.homedir(), ".claude.json") : path.join(configDir, ".claude.json");
 	let raw;
 	try {
 		raw = JSON.parse(readFileSync(file, "utf8"));
 	} catch (error) {
-		if (error.code !== "ENOENT") console.warn(`could not read the Claude account name: ${error}`);
-		return null;
+		if (error.code !== "ENOENT") log$8.warn(`could not read the Claude account:`, error);
+		return {
+			displayName: null,
+			identity: null
+		};
 	}
-	if (!isRecord(raw) || !isRecord(raw.oauthAccount) || typeof raw.oauthAccount.displayName !== "string") return null;
-	const name = raw.oauthAccount.displayName.trim();
-	return name === "" ? null : name;
+	if (!isRecord(raw) || !isRecord(raw.oauthAccount)) return {
+		displayName: null,
+		identity: null
+	};
+	const login = raw.oauthAccount;
+	const name = typeof login.displayName === "string" ? login.displayName.trim() : "";
+	return {
+		displayName: name === "" ? null : name,
+		identity: typeof login.accountUuid === "string" && typeof login.organizationUuid === "string" ? {
+			accountId: login.accountUuid,
+			organizationId: login.organizationUuid
+		} : null
+	};
 }
 function isLinked(configDir) {
 	const base = claudeBaseDir();
@@ -5735,7 +5985,10 @@ var Run = class {
 		try {
 			for await (const message of this.query) this.receive(message);
 		} catch (error) {
-			if (!this.stopping) this.add(notice(error instanceof Error ? error.message : String(error)));
+			if (!this.stopping) {
+				logger.withTag("claude").warn(`${this.sessionId} failed:`, error);
+				this.add(notice(error instanceof Error ? error.message : String(error)));
+			}
 		}
 		clearTimeout(this.idleTimer);
 		for (const id of this.pending.keys()) this.settle(id, {
@@ -6166,7 +6419,7 @@ async function submitFirst(client, run, request, projectId) {
 		from: request.projectId
 	});
 	await run.submit(request.prompt, request.delivery);
-	recordInteraction(sessionId);
+	recordInteraction(sessionId, run.provider);
 }
 async function sendExisting(client, sessionId, cwd, request) {
 	const provider = providerOf(sessionId);
@@ -6180,7 +6433,7 @@ async function sendExisting(client, sessionId, cwd, request) {
 	if (run === existing) await run.configure(request.settings);
 	else await open$1(client, sessionId, request.projectId);
 	await run.submit(request.prompt, request.delivery);
-	recordInteraction(sessionId);
+	recordInteraction(sessionId, provider);
 	if (emptied.has(sessionId) && request.prompt.text.trim() !== "") {
 		emptied.delete(sessionId);
 		await updateSession(sessionId, { title: request.prompt.text.trim() });
@@ -6353,6 +6606,7 @@ function fenced(language, text) {
 	return `${fence}${language}\n${text}\n${fence}`;
 }
 // src/services/message-search.ts
+const log$7 = logger.withTag("search");
 const READ_LIMIT = 30;
 const CODEX_READ_LIMIT = 10;
 const RG_TIME_LIMIT = 5e3;
@@ -6363,7 +6617,6 @@ async function searchMessages(query) {
 		matches: [],
 		failed: []
 	};
-	const paths = new Map(projects().map((project) => [project.path, project.id]));
 	const folders = new Map(projects().map((project) => [project.id, project.path]));
 	const results = await Promise.all([
 		"claude",
@@ -6373,11 +6626,11 @@ async function searchMessages(query) {
 		try {
 			return {
 				provider,
-				matches: await timeLimit(search(provider, query, paths, folders), `${providerName(provider)} did not search in time`),
+				matches: await timeLimit(search(provider, query, folders), `${providerName(provider)} did not search in time`),
 				failed: false
 			};
 		} catch (error) {
-			console.warn(`could not search ${providerName(provider)} messages: ${error}`);
+			log$7.warn(`could not search ${providerName(provider)} messages:`, error);
 			return {
 				provider,
 				matches: [],
@@ -6390,10 +6643,8 @@ async function searchMessages(query) {
 		failed: results.filter((result) => result.failed).map((result) => result.provider)
 	};
 }
-async function search(provider, query, paths, folders) {
-	const found = await find(provider, paths);
-	if (found === null) return [];
-	const sessions = newestFirst(found);
+async function search(provider, query, folders) {
+	const sessions = newestFirst(await providerThreads(provider));
 	switch (provider) {
 		case "claude": return searchClaude(query, sessions, folders);
 		case "codex": return searchCodex(query, sessions);
@@ -6427,7 +6678,7 @@ async function claudeCandidates(query) {
 		const lists = await Promise.all(words.map((word) => sessionsWith(word)));
 		return new Set(lists[0].filter((id) => lists.every((list) => list.includes(id))));
 	} catch (error) {
-		console.warn(`could not narrow Claude sessions with rg: ${error}`);
+		log$7.warn(`could not narrow Claude sessions with rg:`, error);
 		return null;
 	}
 }
@@ -6989,6 +7240,7 @@ function shellIntegrationIssue(command, platform, defaultShell) {
 	return "Available for bash, zsh and fish";
 }
 // src/services/terminal/shell-integration.ts
+const log$6 = logger.withTag("terminal");
 const scripts = path.join(serverDir, "src/services/terminal/shell-integration");
 const folder = path.join(home, "shell-integration");
 function prepare(env, command, shell) {
@@ -7031,7 +7283,7 @@ function zshGlobalsSupported() {
 			contents = readFileSync(global, "utf8");
 		} catch (error) {
 			if (error.code === "ENOENT") continue;
-			console.warn(`could not read ${global}, zsh starts without shell integration: ${error}`);
+			log$6.warn(`could not read ${global}, zsh starts without shell integration:`, error);
 			return false;
 		}
 		for (const rawLine of contents.split("\n")) {
@@ -7076,11 +7328,12 @@ function writeScript(target, source) {
 		renameSync(`${target}.tmp`, target);
 		return true;
 	} catch (error) {
-		console.warn(`could not write ${target}, the shell starts without shell integration: ${error}`);
+		log$6.warn(`could not write ${target}, the shell starts without shell integration:`, error);
 		return false;
 	}
 }
 // src/services/terminal/process.ts
+const log$5 = logger.withTag("terminal");
 const run = promisify(execFile);
 const iterm2Version = "3.6.8";
 const ghosttyVersion = "1.3.1";
@@ -7176,7 +7429,7 @@ async function busyProgram(pid) {
 	try {
 		return await programName(group);
 	} catch (error) {
-		console.warn(`could not read the name of process ${group}: ${error}`);
+		log$5.warn(`could not read the name of process ${group}:`, error);
 		return `process ${group}`;
 	}
 }
@@ -7418,6 +7671,7 @@ var Alerts = class {
 	}
 };
 // src/services/terminal/terminal.ts
+const log$4 = logger.withTag("terminal");
 const HISTORY_LIMIT = 2097152;
 const OUTPUT_LIMIT = 1048576;
 const STALL_LIMIT = 1e4;
@@ -7452,7 +7706,7 @@ async function terminalRequest(client, message) {
 function terminalInput(client, frame) {
 	const connection = connections.get(client);
 	if (connection === void 0) {
-		console.warn("terminal input from a browser that is not attached");
+		log$4.warn("terminal input from a browser that is not attached");
 		return;
 	}
 	input(connection, frame);
@@ -7469,7 +7723,7 @@ async function busyTerminal(id) {
 	try {
 		return { program: await busyProgram(terminal.pty.pid) };
 	} catch (error) {
-		console.warn(`could not tell if terminal ${id} is busy: ${error}`);
+		log$4.warn(`could not tell if terminal ${id} is busy:`, error);
 		return { error: String(error) };
 	}
 }
@@ -7538,12 +7792,12 @@ function input(connection, bytes) {
 	try {
 		frame = decodeFrame(bytes);
 	} catch (error) {
-		console.warn(`ignoring terminal input: ${error}`);
+		log$4.warn(`ignoring terminal input:`, error);
 		return;
 	}
 	const terminal = terminals.get(frame.id);
 	if (terminal === void 0) {
-		console.warn(`input for terminal ${frame.id}, which does not exist`);
+		log$4.warn(`input for terminal ${frame.id}, which does not exist`);
 		return;
 	}
 	if (frame.kind === 1) {
@@ -7555,7 +7809,7 @@ function input(connection, bytes) {
 			terminal.pty.resize(size.cols, size.rows);
 		}
 	} else {
-		console.warn(`ignoring terminal input of unknown kind ${frame.kind}`);
+		log$4.warn(`ignoring terminal input of unknown kind ${frame.kind}`);
 		return;
 	}
 	terminal.pty.write(Buffer.from(frame.data));
@@ -7563,7 +7817,7 @@ function input(connection, bytes) {
 async function createTab(projectId) {
 	const cwd = projectId === null ? workingDirectory() : projectPath(projectId);
 	if (!statSync(cwd, { throwIfNoEntry: false })?.isDirectory()) {
-		console.error(`${cwd} is not a folder, terminal not created`);
+		log$4.error(`${cwd} is not a folder, terminal not created`);
 		return;
 	}
 	const activeId = active.get(projectId ?? "global");
@@ -7572,7 +7826,7 @@ async function createTab(projectId) {
 	if (current !== void 0) try {
 		directory = await currentDirectory(current.pty.pid, current.scanner.directory);
 	} catch (error) {
-		console.warn(`starting in the project folder, could not read the folder of the active terminal: ${error}`);
+		log$4.warn(`starting in the project folder, could not read the folder of the active terminal:`, error);
 	}
 	nextTab += 1;
 	const id = nextTab;
@@ -7580,7 +7834,7 @@ async function createTab(projectId) {
 	try {
 		pty = startShell(directory);
 	} catch (error) {
-		console.error(`could not start terminal ${id}: ${error}`);
+		log$4.error(`could not start terminal ${id}:`, error);
 		return;
 	}
 	const terminal = {
@@ -7591,6 +7845,7 @@ async function createTab(projectId) {
 		alerts: new Alerts(),
 		scanner: new Scanner()
 	};
+	log$4.info(`started terminal ${id} with pid ${pty.pid} in ${directory}`);
 	terminals.set(id, terminal);
 	tabs.push({
 		id,
@@ -7603,7 +7858,8 @@ async function createTab(projectId) {
 		pty.pause();
 		held.add(pty);
 	}
-	pty.onExit(() => {
+	pty.onExit((event) => {
+		log$4.info(`terminal ${id} exited with code ${event.exitCode}`);
 		terminals.delete(id);
 		paused.delete(pty);
 		held.delete(pty);
@@ -7613,6 +7869,7 @@ async function createTab(projectId) {
 function closeTab(id) {
 	const tab = findTab(id);
 	if (tab === void 0) return false;
+	log$4.debug(`closing terminal ${id}`);
 	release(tab);
 	tabs.splice(tabs.indexOf(tab), 1);
 	const terminal = terminals.get(id);
@@ -7654,7 +7911,7 @@ function drain() {
 			last.queued = queued;
 			progress.set(connection, last);
 			if (now - last.at > STALL_LIMIT) {
-				console.warn("a browser is not reading fast enough, disconnecting it");
+				log$4.warn("a browser is not reading fast enough, disconnecting it");
 				connection.client.socket.terminate();
 				continue;
 			}
@@ -7744,6 +8001,36 @@ function send(connection, event) {
 		event
 	});
 }
+// src/storage/last-used.ts
+const lastUsedSchema = z.discriminatedUnion("provider", [z.strictObject({
+	provider: z.enum(["claude", "codex"]),
+	accountId: z.string(),
+	model: z.string()
+}), z.strictObject({
+	provider: z.literal("opencode"),
+	accountId: z.null(),
+	model: z.string()
+})]);
+function readLastUsed() {
+	return db.select().from(lastUsedModels).all();
+}
+function saveLastUsed(value) {
+	const result = lastUsedSchema.safeParse(value);
+	if (!result.success) throw new Error(z.prettifyError(result.error));
+	const row = {
+		...result.data,
+		usedAt: Date.now()
+	};
+	db.insert(lastUsedModels).values(row).onConflictDoUpdate({
+		target: lastUsedModels.provider,
+		set: row
+	}).run();
+	broadcast({
+		type: "lastUsed",
+		lastUsed: readLastUsed()
+	});
+	return null;
+}
 // ../core/src/app-icons.ts
 const appIcons = [
 	{
@@ -7814,77 +8101,14 @@ const appIcons = [
 	}
 ];
 // src/storage/state.ts
-const stateSchema = z.strictObject({
-	composer: z.strictObject({
-		provider: z.enum([
-			"claude",
-			"codex",
-			"opencode"
-		]).default("claude"),
-		claude: z.strictObject({
-			accountId: z.string().nullable().default(null),
-			model: z.string().nullable().default(null),
-			effort: z.enum([
-				"low",
-				"medium",
-				"high",
-				"xhigh",
-				"max"
-			]).nullable().default(null),
-			mode: z.enum([
-				"default",
-				"acceptEdits",
-				"bypassPermissions",
-				"plan",
-				"dontAsk",
-				"auto"
-			]).nullable().default("bypassPermissions"),
-			plan: z.boolean().default(false)
-		}).prefault({}),
-		codex: z.strictObject({
-			accountId: z.string().nullable().default(null),
-			model: z.string().nullable().default(null),
-			effort: z.string().nullable().default(null),
-			mode: z.enum([
-				"read-only",
-				"auto",
-				"full-access"
-			]).nullable().default("auto"),
-			plan: z.boolean().default(false)
-		}).prefault({}),
-		opencode: z.strictObject({
-			accountId: z.null().default(null),
-			model: z.string().nullable().default(null),
-			effort: z.string().nullable().default(null),
-			mode: z.string().nullable().default(null),
-			plan: z.boolean().default(false)
-		}).prefault({})
-	}).prefault({}),
-	appIcon: z.custom((value) => appIcons.some((icon) => icon.id === value)).default("original")
-});
+const stateSchema = z.strictObject({ appIcon: z.custom((value) => appIcons.some((icon) => icon.id === value)).default("original") });
 const defaults = stateSchema.parse({});
 function readState() {
 	return readSettings("state.json", stateSchema, defaults);
 }
-function readComposer() {
-	return readState().composer;
-}
 function readAppIcon() {
 	return readState().appIcon;
 }
-function saveComposer(value) {
-	const result = stateSchema.safeParse({
-		...readState(),
-		composer: value
-	});
-	if (!result.success) throw new Error(z.prettifyError(result.error));
-	writeJson("state.json", result.data);
-	broadcast({
-		type: "composer",
-		composer: result.data.composer
-	});
-	return result.data.composer;
-}
 function saveAppIcon(value) {
 	const result = stateSchema.safeParse({
 		...readState(),
@@ -7899,13 +8123,14 @@ function saveAppIcon(value) {
 	return result.data.appIcon;
 }
 // src/api/socket.ts
+const log$3 = logger.withTag("socket");
 const handlers = {
 	ping: () => null,
 	sync: () => {
 		refreshAll();
 		return {
 			...configInfo(),
-			composer: readComposer(),
+			lastUsed: readLastUsed(),
 			hostname: os.hostname(),
 			projects: projects(),
 			sessions: sessions(),
@@ -7916,8 +8141,7 @@ const handlers = {
 		};
 	},
 	"config.get": () => configInfo(),
-	"composer.get": () => readComposer(),
-	"composer.save": (params) => saveComposer(params),
+	"lastUsed.save": (params) => saveLastUsed(params),
 	"appIcon.save": (params) => saveAppIcon(params),
 	"config.save": async (params) => {
 		const before = readConfig();
@@ -7973,7 +8197,7 @@ const handlers = {
 		if (params.opened && session !== null) recordOpen(params.sessionId, params.query);
 		return session;
 	},
-	"sessions.inactive": (params) => inactiveSessions(params.projectId),
+	"sessions.inactive": (params) => inactiveSessions(params),
 	"sessions.searchable": () => searchableSessions(),
 	"sessions.searchMessages": (params) => searchMessages(params.query),
 	"sessions.earlier": (params) => earlier(params.sessionId, params.before),
@@ -8014,7 +8238,7 @@ const handlers = {
 		const run = runs.get(params.sessionId);
 		if (run === void 0) return null;
 		await run.respond(params.requestId, params.decision, params.answers);
-		recordInteraction(params.sessionId);
+		recordInteraction(params.sessionId, run.provider);
 		return null;
 	},
 	"sessions.rewind": (params) => rewind(params),
@@ -8128,6 +8352,7 @@ function connectClient(socket, device, address) {
 		send: (message) => socket.send(JSON.stringify(message))
 	};
 	clients.add(client);
+	log$3.info(`a browser connected from ${address}`);
 	socket.on("message", (data, isBinary) => {
 		client.heardAt = Date.now();
 		if (isBinary) {
@@ -8136,8 +8361,9 @@ function connectClient(socket, device, address) {
 		}
 		answer(client, String(data));
 	});
-	socket.on("error", (error) => console.warn(`a browser connection failed: ${error}`));
-	socket.on("close", () => {
+	socket.on("error", (error) => log$3.warn(`a browser connection from ${address} failed:`, error));
+	socket.on("close", (code) => {
+		log$3.info(`a browser from ${address} disconnected (code ${code})`);
 		clients.delete(client);
 		detachTerminal(client);
 	});
@@ -8147,9 +8373,10 @@ async function answer(client, text) {
 	try {
 		call = JSON.parse(text);
 	} catch (error) {
-		console.warn(`ignoring a message that is not JSON: ${error}`);
+		log$3.warn(`ignoring a message from ${client.address} that is not JSON:`, error);
 		return;
 	}
+	const started = performance.now();
 	try {
 		if (!Object.hasOwn(handlers, call.method)) throw new Error(`unknown method ${call.method}`);
 		const handler = handlers[call.method];
@@ -8160,11 +8387,15 @@ async function answer(client, text) {
 			result
 		});
 	} catch (error) {
+		log$3.warn(`${call.method} from ${client.address} failed:`, error);
 		client.send({
 			type: "reply",
 			id: call.id,
 			error: error instanceof Error ? error.message : String(error)
 		});
+	} finally {
+		const took = Math.round(performance.now() - started);
+		if (call.method !== "ping") log$3.debug(`${call.method} from ${client.address} took ${took}ms`);
 	}
 }
 // src/lib/proxy/css.ts
@@ -9337,6 +9568,7 @@ function fail(response, status, message) {
 	response.end(message);
 }
 // src/services/app-icon.ts
+const log$2 = logger.withTag("app-icon");
 const pngs = /* @__PURE__ */ new Map([
 	["icon-192.png", {
 		size: 192,
@@ -9369,7 +9601,7 @@ async function serveAppIcon(publicDir, pathname, response) {
 		response.setHeader("cache-control", "no-cache");
 		response.end(icon.body);
 	} catch (error) {
-		console.warn(`could not serve the app icon: ${error}`);
+		log$2.warn(`could not serve the app icon:`, error);
 		response.statusCode = 500;
 		response.end("could not render the app icon");
 	}
@@ -9401,10 +9633,83 @@ function tile(icon, maskable) {
 	if (icon.tile.shape === "circle") return `<circle cx="256" cy="256" r="256" fill="${icon.tile.color}"/>`;
 	throw new Error(`unknown tile shape for ${icon.id}`);
 }
+// src/services/backfill-session-providers.ts
+const log$1 = logger.withTag("backfill");
+const allProviders = [
+	"claude",
+	"codex",
+	"opencode"
+];
+async function backfillSessionProviders() {
+	const rows = db.select().from(sessions$1).where(isNull(sessions$1.provider)).all();
+	if (rows.length === 0) return;
+	const paths = new Map(projects().map((project) => [project.path, project.id]));
+	const enabled = allProviders.filter((provider) => readConfig().enabledProviders[provider]);
+	for (const row of rows) {
+		const answers = await Promise.all(enabled.map(async (provider) => {
+			try {
+				return await timeLimit(info(provider, row.sessionId, paths), `${providerName(provider)} did not answer in time`) !== null;
+			} catch (error) {
+				log$1.debug(`${providerName(provider)} does not know session ${row.sessionId}:`, error);
+				return false;
+			}
+		}));
+		const owners = enabled.filter((_, index) => answers[index]);
+		if (owners.length !== 1) {
+			log$1.warn(`${owners.length} providers know session ${row.sessionId}, it stays without a provider until the next start`);
+			continue;
+		}
+		db.update(sessions$1).set({ provider: owners[0] }).where(eq(sessions$1.sessionId, row.sessionId)).run();
+		log$1.info(`saved ${providerName(owners[0])} as the provider of session ${row.sessionId}`);
+	}
+}
+// src/services/browser-logs.ts
+const logsBody = z.array(z.object({
+	time: z.number(),
+	type: z.enum([
+		"fatal",
+		"error",
+		"warn",
+		"log",
+		"info",
+		"success",
+		"fail",
+		"ready",
+		"start",
+		"box",
+		"debug",
+		"trace",
+		"verbose"
+	]),
+	tag: z.string(),
+	message: z.string()
+}));
+async function saveBrowserLogs(device, request, response) {
+	let body = "";
+	for await (const chunk of request) body += chunk;
+	let entries;
+	try {
+		entries = logsBody.parse(JSON.parse(body));
+	} catch {
+		response.statusCode = 400;
+		response.end("expected [{ time, type, tag, message }]");
+		return;
+	}
+	const source = device === null ? request.socket.remoteAddress ?? "unknown address" : readDevices().find((item) => item.hash === device)?.name ?? "Unnamed";
+	for (const entry of entries) browserLogger.log({
+		date: new Date(entry.time),
+		type: entry.type,
+		tag: entry.tag,
+		args: [`${source}: ${entry.message}`]
+	});
+	response.statusCode = 204;
+	response.end();
+}
 // src/main.ts
 const UNPAIR_CHECK = 5e3;
 const TICKET_LIFETIME = 6e4;
 const openBody = z.object({ path: z.string() });
+const log = logger.withTag("server");
 const contentTypes = {
 	".html": "text/html; charset=utf-8",
 	".js": "text/javascript; charset=utf-8",
@@ -9440,6 +9745,7 @@ const browseTypes = new Map([
 const port = Number(listenPort());
 if (!Number.isInteger(port) || port < 1 || port > 65535) {
 	console.error(`invalid port ${args.port}`);
+	log.error(`invalid port ${args.port}`);
 	process.exit(1);
 }
 const address = `http://${args.host}:${port}`;
@@ -9454,12 +9760,15 @@ if (args.command === "unpair") {
 	process.exit(0);
 }
 lockHome();
+log.info(`starting offsite ${args.command} with pid ${process.pid} on ${address}, dir ${args.dir}, auth ${args.auth ? "on" : "off"}`);
 process.env.CLAUDE_CONFIG_DIR = claudeBaseDir();
 installOpen(args.host, port);
+await backfillSessionProviders();
 watchSessions();
 refreshAll();
 if (findClaude() === null) {
 	console.error("could not find claude on PATH; install Claude Code first");
+	log.error("could not find claude on PATH; install Claude Code first");
 	process.exit(1);
 }
 const publicDir = path.join(import.meta.dirname, "..", "..", "client", "dist");
@@ -9469,7 +9778,7 @@ const server = createServer((request, response) => {
 	try {
 		answerRequest(request, response);
 	} catch (error) {
-		console.warn(`a request failed: ${error}`);
+		log.warn("a request failed:", error);
 		if (response.headersSent) {
 			response.destroy();
 			return;
@@ -9559,11 +9868,16 @@ server.listen(port, args.host, () => {
 		console.log(`offsite is running at ${address}`);
 		if (args.auth && args.pair) console.log("Run offsite pair to pair another browser");
 	}
-	if (!args.auth) console.warn("auth is off; anyone who can reach this port can control this machine");
+	log.info(`listening on ${address}`);
+	if (!args.auth) {
+		console.warn("auth is off; anyone who can reach this port can control this machine");
+		log.warn("auth is off; anyone who can reach this port can control this machine");
+	}
 });
 process.on("SIGINT", stop);
 process.on("SIGTERM", stop);
-function stop() {
+function stop(signal) {
+	log.info(`stopping on ${signal}`);
 	stopAll();
 	process.exit(0);
 }
@@ -9592,6 +9906,16 @@ function answerApi(pathname, request, response) {
 		answerJson(response, { token });
 		return;
 	}
+	if (pathname === "/api/logs") {
+		const device = given === null ? null : findDevice(given);
+		if (args.auth && device === null) {
+			response.statusCode = 401;
+			response.end("This browser needs pairing");
+			return;
+		}
+		saveBrowserLogs(device, request, response);
+		return;
+	}
 	if (pathname === "/api/ticket") {
 		if (!args.auth) {
 			answerJson(response, { ticket: null });