offsite 0.0.94 → 0.0.96

package/apps/server/dist/main.mjs

@@ -1,5 +1,5 @@
 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, writeSync } from "node:fs";
+import { accessSync, appendFileSync, chmodSync, closeSync, constants, createReadStream, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, rmdirSync, statSync, symlinkSync, unlinkSync, watch, writeFileSync, writeSync } from "node:fs";
 import http, { createServer } from "node:http";
 import path from "node:path";
 import zlib, { createGzip } from "node:zlib";
@@ -22,7 +22,7 @@ import { sumBy } from "es-toolkit";
 import { DatabaseSync } from "node:sqlite";
 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 { integer, primaryKey, real, snakeCase, text } from "drizzle-orm/sqlite-core";
 import sharp from "sharp";
 import webPush from "web-push";
 import dns from "node:dns";
@@ -302,6 +302,29 @@ function notice(text) {
 		isError: true
 	};
 }
+function resultNotice(message) {
+	if (message.subtype === "success" || message.terminal_reason === "aborted_streaming" || message.terminal_reason === "aborted_tools") return null;
+	return notice(message.errors.filter((error) => !error.startsWith("[ede_diagnostic]")).join("\n") || message.subtype);
+}
+const failingReasons = [
+	"api_error",
+	"malformed_tool_use_exhausted",
+	"budget_exhausted",
+	"structured_output_retry_exhausted",
+	"tool_deferred_unavailable",
+	"turn_setup_failed",
+	"blocking_limit",
+	"rapid_refill_breaker",
+	"prompt_too_long",
+	"image_error",
+	"model_error"
+];
+function turnFailed(message) {
+	if (message.terminal_reason === "aborted_tools" || message.terminal_reason === "aborted_streaming") return false;
+	if (message.subtype === "success") return message.api_error_status === 429 || message.api_error_status === 529 || message.is_error && message.api_error_status === 403 || failingReasons.includes(message.terminal_reason);
+	const errors = message.errors.join("\n").toLowerCase();
+	return !errors.includes("interrupt") && !errors.includes("cancel");
+}
 function contextTokens(message) {
 	if (!isRecord(message) || !isRecord(message.usage)) return null;
 	const usage = message.usage;
@@ -459,18 +482,26 @@ function readJson(name) {
 		throw error;
 	}
 }
-function readSettings(name, schema, defaults) {
+function readSettings(name, schema, defaults, migrate = (value) => value) {
 	const file = path.join(home, name);
-	let value;
+	let saved;
 	try {
-		value = readJson(name);
+		saved = readJson(name);
 	} catch (error) {
 		log$19.warn(`invalid ${file}, using the defaults:`, error);
 		return structuredClone(defaults);
 	}
-	if (value === null) return structuredClone(defaults);
+	if (saved === null) return structuredClone(defaults);
+	const value = migrate(saved);
+	if (value !== saved) {
+		writeJson(`${name}.bak`, saved);
+		log$19.info(`migrated ${file}, the old file is in ${file}.bak`);
+	}
 	let result = schema.safeParse(value);
-	if (result.success) return result.data;
+	if (result.success) {
+		if (value !== saved) writeJson(name, result.data);
+		return result.data;
+	}
 	while (!result.success) {
 		const issue = result.error.issues[0];
 		const targets = issue.code === "unrecognized_keys" ? issue.keys.map((key) => [...issue.path, key]) : [issue.path];
@@ -525,11 +556,11 @@ function installOpen(host, port) {
 		"wslview"
 	]) {
 		const wrapper = path.join(folder, name);
-		writeFileSync(wrapper, `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(script)} ${name} "$@"\n`);
+		writeFileSync(wrapper, `#!/bin/sh\nexec ${quote$1(process.execPath)} ${quote$1(script)} ${name} "$@"\n`);
 		chmodSync(wrapper, 493);
 	}
 	const startup = path.join(folder, "env.sh");
-	writeFileSync(startup, `export PATH=${quote(folder)}:"$PATH"\n`);
+	writeFileSync(startup, `export PATH=${quote$1(folder)}:"$PATH"\n`);
 	env = {
 		PATH: process.env.PATH === void 0 ? folder : `${folder}${path.delimiter}${process.env.PATH}`,
 		BROWSER: path.join(folder, process.platform === "darwin" ? "open" : "xdg-open"),
@@ -544,7 +575,7 @@ function loopback(host) {
 	if (host.includes(":")) return `[${host}]`;
 	return host;
 }
-function quote(value) {
+function quote$1(value) {
 	return `'${value.replaceAll("'", "'\\''")}'`;
 }
 // src/lib/codex/app-server.ts
@@ -722,7 +753,11 @@ var AppServer = class {
 			publishCodexLimits(this.home, params.rateLimits);
 			return;
 		}
-		listener?.notify(message.method, params);
+		if (listener === void 0) {
+			owner?.notifyAgent?.(message.method, params);
+			return;
+		}
+		listener.notify(message.method, params);
 	}
 	rootOf(threadId) {
 		if (typeof threadId !== "string") return;
@@ -1130,10 +1165,7 @@ function record$1(value) {
 	return isRecord(value) ? value : { value };
 }
 // src/storage/config.ts
-const modelSetting = z.strictObject({
-	hidden: z.boolean(),
-	effort: z.string().nullable()
-});
+const modelSetting = z.strictObject({ hidden: z.boolean() });
 const generationModel = z.strictObject({
 	provider: z.enum([
 		"claude",
@@ -1162,27 +1194,31 @@ function accountSchema(provider) {
 		enabled: z.boolean().default(true)
 	});
 }
+const modelSettings = z.record(z.string(), modelSetting).default({});
 const configSchema = z.strictObject({
-	claudeBaseDir: platformDirs,
+	version: z.literal(2).default(2),
+	claude: z.strictObject({
+		enabled: z.boolean().default(true),
+		baseDir: platformDirs,
+		accounts: z.array(accountSchema("claude")).default([]),
+		models: modelSettings
+	}).prefault({}),
+	codex: z.strictObject({
+		enabled: z.boolean().default(true),
+		accounts: z.array(accountSchema("codex")).default([]),
+		models: modelSettings
+	}).prefault({}),
+	opencode: z.strictObject({
+		enabled: z.boolean().default(true),
+		models: modelSettings
+	}).prefault({}),
 	workingDir: z.strictObject({
 		macos: workingDir(path.posix.isAbsolute),
 		linux: workingDir(path.posix.isAbsolute),
 		windows: workingDir(path.win32.isAbsolute)
 	}).prefault({}),
-	claudeAccounts: z.array(accountSchema("claude")).default([]),
-	codexAccounts: z.array(accountSchema("codex")).default([]),
-	enabledProviders: z.strictObject({
-		claude: z.boolean().default(true),
-		codex: z.boolean().default(true),
-		opencode: z.boolean().default(true)
-	}).prefault({}),
 	commitMessage: generationModel,
 	titleGeneration: generationModel,
-	models: z.strictObject({
-		claude: z.record(z.string(), modelSetting).default({}),
-		codex: z.record(z.string(), modelSetting).default({}),
-		opencode: z.record(z.string(), modelSetting).default({})
-	}).prefault({}),
 	delivery: z.enum(["queue", "steer"]).default("steer"),
 	autoSkipQuestionTimeout: z.number().positive().nullable().default(180),
 	autoPermissionMode: z.enum([
@@ -1216,7 +1252,7 @@ function platform() {
 	throw new Error(`unsupported platform ${process.platform}`);
 }
 function claudeBaseDir() {
-	return readConfig().claudeBaseDir[platform()] ?? path.join(os.homedir(), ".claude");
+	return readConfig().claude.baseDir[platform()] ?? path.join(os.homedir(), ".claude");
 }
 function workingDirectory() {
 	const dir = readConfig().workingDir[platform()] ?? "~";
@@ -1234,11 +1270,42 @@ function configInfo() {
 		defaultShell: defaultShell(),
 		defaultClaudeBaseDir: path.join(os.homedir(), ".claude"),
 		homeDir: os.homedir(),
-		scratchAvailable
+		scratchAvailable,
+		version: "v0.0.96"
 	};
 }
 function readConfig() {
-	return readSettings("config.json", configSchema, defaults$1);
+	return readSettings("config.json", configSchema, defaults$1, migrate$1);
+}
+function migrate$1(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+	if (!("version" in value)) return fromVersion1(value);
+	if (value.version === 2) return value;
+	throw new Error(`config.json has version ${String(value.version)}, which this version of offsite cannot read. Update offsite`);
+}
+function fromVersion1(value) {
+	const { claudeBaseDir, claudeAccounts, codexAccounts, enabledProviders, models, ...rest } = value;
+	const enabled = enabledProviders ?? {};
+	const providerModels = models ?? {};
+	return {
+		...rest,
+		version: 2,
+		claude: {
+			enabled: enabled.claude,
+			baseDir: claudeBaseDir,
+			accounts: claudeAccounts,
+			models: providerModels.claude
+		},
+		codex: {
+			enabled: enabled.codex,
+			accounts: codexAccounts,
+			models: providerModels.codex
+		},
+		opencode: {
+			enabled: enabled.opencode,
+			models: providerModels.opencode
+		}
+	};
 }
 function saveConfig(value) {
 	const result = configSchema.safeParse(value);
@@ -1266,6 +1333,7 @@ function activity() {
 		prompted: run.prompted,
 		compacting: run.compacting,
 		backgroundAgent: run.backgroundAgents > 0,
+		holdsCompletion: !run.failed && run.agentTasks > 0,
 		tasks: run.tasks
 	};
 	return result;
@@ -1314,6 +1382,24 @@ function scheduleAutoResolve(sessionId, request) {
 		}
 	};
 }
+// src/lib/codex/agents.ts
+function trackAgents(agents, method, params) {
+	const threadId = params.threadId;
+	if (method === "turn/started" && agents.has(threadId)) agents.set(threadId, true);
+	if (method === "turn/completed" && agents.has(threadId)) agents.set(threadId, false);
+	if (method !== "item/completed") return;
+	const item = params.item;
+	if (item.type === "subAgentActivity") {
+		if (item.kind === "started" && !agents.has(item.agentThreadId)) agents.set(item.agentThreadId, true);
+		if ((item.kind === "interrupted" || item.kind === "completed") && agents.has(item.agentThreadId)) agents.set(item.agentThreadId, false);
+	}
+	if (item.type === "collabAgentToolCall") {
+		if (item.tool === "spawnAgent") {
+			for (const agent of item.receiverThreadIds) if (!agents.has(agent)) agents.set(agent, true);
+		}
+		for (const [agent, state] of Object.entries(item.agentsStates)) if (agents.get(agent) === true) agents.set(agent, state.status === "pendingInit" || state.status === "running");
+	}
+}
 // src/lib/codex/presets.ts
 const presets = /* @__PURE__ */ new Map([
 	["read-only", {
@@ -1466,11 +1552,13 @@ var CodexRun = class CodexRun {
 	compacting = false;
 	backgroundTasks = 0;
 	backgroundAgents = 0;
+	failed = false;
 	tasks = {};
 	activeAt = Date.now();
 	model;
 	close;
 	turnId = null;
+	agents = /* @__PURE__ */ new Map();
 	idleTimer;
 	static async start(cwd, settings) {
 		const server = codexServer(settings);
@@ -1579,6 +1667,7 @@ var CodexRun = class CodexRun {
 	}
 	notify(method, params) {
 		this.activeAt = Date.now();
+		this.notifyAgent(method, params);
 		switch (method) {
 			case "turn/started": {
 				const turn = params.turn;
@@ -1592,6 +1681,7 @@ var CodexRun = class CodexRun {
 			case "turn/completed": {
 				const turn = params.turn;
 				if (turn.status === "failed" && turn.error !== null) this.put(errorItem(`${turn.id}:error`, turn.error.message));
+				this.failed = turn.status === "failed" || turn.status === "inProgress";
 				this.finishTurn();
 				return;
 			}
@@ -1657,6 +1747,14 @@ var CodexRun = class CodexRun {
 			case "serverRequest/resolved": this.settle(String(params.requestId));
 		}
 	}
+	notifyAgent(method, params) {
+		const running = this.agentTasks;
+		trackAgents(this.agents, method, params);
+		if (this.agentTasks !== running) broadcastActivity();
+	}
+	get agentTasks() {
+		return [...this.agents.values()].filter((running) => running).length;
+	}
 	request(id, method, params) {
 		if (method === "mcpServer/elicitation/request") {
 			this.server.reply(id, {
@@ -2667,6 +2765,8 @@ var OpenCodeRun = class OpenCodeRun {
 	compacting = false;
 	backgroundTasks = 0;
 	backgroundAgents = 0;
+	agentTasks = 0;
+	failed = false;
 	tasks = {};
 	close;
 	applied;
@@ -3057,6 +3157,15 @@ const lastUsedModels = snakeCase.table("last_used_models", {
 	model: text().notNull(),
 	usedAt: integer().notNull()
 });
+const lastEfforts = snakeCase.table("last_efforts", {
+	provider: text({ enum: [
+		"claude",
+		"codex",
+		"opencode"
+	] }).notNull(),
+	model: text().notNull(),
+	effort: text()
+}, (table) => [primaryKey({ columns: [table.provider, table.model] })]);
 // src/storage/auth.ts
 const CODE_LIFETIME = 3e5;
 const DEVICE_LIFETIME = 2592e6;
@@ -3443,7 +3552,7 @@ const UNTRACKED_LIMIT = 100;
 const NEW_FILE_LIMIT = 262144;
 const REPO_DEPTH = 3;
 const FETCH_TIMEOUT = 6e4;
-const run$3 = promisify(execFile);
+const run$4 = promisify(execFile);
 const PULL_REQUEST_INSTRUCTIONS = `You write GitHub pull requests as Markdown.
 
 ## TITLE RULES
@@ -3475,6 +3584,7 @@ Return one Markdown document. The title is the level-1 heading (\`# <title>\`),
 async function gitRepos(cwd) {
 	return Promise.all((await projectRepos(cwd)).map(async (repo) => ({
 		...await gitStatus(path.join(cwd, repo)),
+		...await lineChanges(path.join(cwd, repo)),
 		path: repo
 	})));
 }
@@ -3535,7 +3645,7 @@ async function sync(cwd) {
 async function fetchProject(cwd) {
 	await Promise.all((await projectRepos(cwd)).map(async (repo) => {
 		try {
-			await run$3("git", ["fetch"], {
+			await run$4("git", ["fetch"], {
 				cwd: path.join(cwd, repo),
 				env: {
 					...process.env,
@@ -3566,7 +3676,7 @@ async function switchBranch(cwd, branch, create) {
 async function pullRequestBranches(cwd) {
 	const head = (await gitStatus(cwd)).branch;
 	if (head === null) throw new Error("Not on a branch");
-	const base = (await run$3("gh", [
+	const base = (await run$4("gh", [
 		"repo",
 		"view",
 		"--json",
@@ -3591,7 +3701,7 @@ async function preparePullRequest(cwd, base, commitChanges) {
 	if (commitChanges) await commit(cwd, "", true);
 	const status = await gitStatus(cwd);
 	if (status.upstream === null || status.ahead > 0) await push$1(cwd);
-	const open = (await run$3("gh", [
+	const open = (await run$4("gh", [
 		"pr",
 		"list",
 		"--head",
@@ -3638,7 +3748,7 @@ async function preparePullRequest(cwd, base, commitChanges) {
 	};
 }
 async function createPullRequest(cwd, request) {
-	const url = (await run$3("gh", [
+	const url = (await run$4("gh", [
 		"pr",
 		"create",
 		"--title",
@@ -3671,7 +3781,7 @@ async function projectDiff(cwd) {
 	return (await Promise.all(repos.map((repo) => repoDiff(path.join(cwd, repo), repo === "" ? "" : `${repo}/`)))).join("");
 }
 function git(cwd, args) {
-	return run$3("git", args, {
+	return run$4("git", args, {
 		cwd,
 		maxBuffer: 67108864
 	});
@@ -3708,6 +3818,19 @@ async function gitStatus(cwd) {
 	}
 	return status;
 }
+async function lineChanges(repo) {
+	let added = 0;
+	let removed = 0;
+	let hunk = false;
+	for (const line of (await repoDiff(repo, "")).split("\n")) if (line.startsWith("diff --git ")) hunk = false;
+	else if (line.startsWith("@@")) hunk = true;
+	else if (hunk && line.startsWith("+")) added++;
+	else if (hunk && line.startsWith("-")) removed++;
+	return {
+		added,
+		removed
+	};
+}
 async function rebaseOnUpstream(cwd) {
 	try {
 		await git(cwd, ["rebase", "@{upstream}"]);
@@ -4130,8 +4253,10 @@ function rebuildThreads() {
 	const config = readConfig();
 	const key = JSON.stringify([
 		projectPaths$1(),
-		config.enabledProviders,
-		config.claudeBaseDir
+		config.claude.enabled,
+		config.codex.enabled,
+		config.opencode.enabled,
+		config.claude.baseDir
 	]);
 	if (key === builtFor) return;
 	builtFor = key;
@@ -4145,7 +4270,7 @@ function threadFailed(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));
+	return allProviders$2.filter((provider) => readConfig()[provider].enabled).flatMap((provider) => [...threads[provider].values()]).filter((item) => known.has(item.projectId));
 }
 async function providerThreads(provider) {
 	await built;
@@ -4220,7 +4345,7 @@ async function relistAll() {
 	await Promise.all(allProviders$2.map((provider) => relist(provider)));
 }
 async function relist(provider) {
-	if (!readConfig().enabledProviders[provider]) {
+	if (!readConfig()[provider].enabled) {
 		threads[provider] = /* @__PURE__ */ new Map();
 		failures.delete(provider);
 		broadcast({ type: "threads" });
@@ -4320,7 +4445,7 @@ function withStatus(items) {
 	});
 }
 function enabledProviders() {
-	return allProviders$1.filter((provider) => readConfig().enabledProviders[provider]);
+	return allProviders$1.filter((provider) => readConfig()[provider].enabled);
 }
 function projectPaths() {
 	return projects().map((project) => [project.path, project.id]);
@@ -4339,18 +4464,18 @@ 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, provider) {
+function recordInteraction(id, provider, status) {
 	db.insert(sessions$1).values({
 		sessionId: id,
 		provider,
 		interactedAt: Date.now(),
-		status: "active"
+		status: 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`
+			status: status === null ? sql`CASE ${sessions$1.status} WHEN 'pinned' THEN 'pinned' WHEN 'snoozed' THEN 'snoozed' WHEN 'minimized' THEN 'minimized' ELSE 'active' END` : sql`CASE ${sessions$1.status} WHEN 'pinned' THEN 'pinned' ELSE ${status} END`
 		}
 	}).run();
 }
@@ -4400,7 +4525,7 @@ async function list(provider) {
 	const paths = new Map(projectPaths());
 	const before = statuses[provider];
 	try {
-		if (!readConfig().enabledProviders[provider]) {
+		if (!readConfig()[provider].enabled) {
 			listed[provider] = [];
 			statuses[provider] = {
 				provider,
@@ -4455,7 +4580,7 @@ async function lookup(provider, sessionId, paths) {
 function watchSessions() {
 	for (const watcher of watchers) watcher.close();
 	watchers = [["claude", path.join(claudeBaseDir(), "projects")], ["codex", path.join(codexBaseDir, "sessions")]].flatMap(([provider, dir]) => {
-		if (!readConfig().enabledProviders[provider]) return [];
+		if (!readConfig()[provider].enabled) return [];
 		try {
 			const watcher = watch(dir, { recursive: true }, (_, filename) => {
 				fileChanged(provider, filename);
@@ -4549,7 +4674,7 @@ 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, provider);
+	recordInteraction(result.sessionId, provider, null);
 	markChanged(provider, result.sessionId);
 	refreshSessions(provider);
 	return result;
@@ -4695,16 +4820,16 @@ function providerName(provider) {
 }
 function storedAccounts() {
 	const config = readConfig();
-	return [...config.claudeAccounts.map((item) => ({
+	return [...config.claude.accounts.map((item) => ({
 		...item,
 		configDir: item.configDir[platform()]
-	})), ...config.codexAccounts.map((item) => ({
+	})), ...config.codex.accounts.map((item) => ({
 		...item,
 		configDir: item.configDir[platform()]
 	}))];
 }
 function assertEnabled(provider, accountId) {
-	if (!readConfig().enabledProviders[provider]) throw new Error(`${providerName(provider)} is disabled in Settings`);
+	if (!readConfig()[provider].enabled) throw new Error(`${providerName(provider)} is disabled in Settings`);
 	if (provider === "opencode") return;
 	if (!storedAccount(provider, accountId).enabled) throw new Error("That account is disabled in Settings");
 }
@@ -4734,7 +4859,7 @@ function storedAccount(provider, accountId) {
 }
 async function accounts() {
 	const stored = await Promise.all(storedAccounts().map((account) => {
-		if (!account.enabled || !readConfig().enabledProviders[account.provider]) return disabledAccount(account);
+		if (!account.enabled || !readConfig()[account.provider].enabled) return disabledAccount(account);
 		switch (account.provider) {
 			case "claude": return claudeAccount(account);
 			case "codex": return codexAccount(account);
@@ -4743,7 +4868,7 @@ async function accounts() {
 	return {
 		claudeAccounts: stored.filter((item) => item.provider === "claude"),
 		codexAccounts: stored.filter((item) => item.provider === "codex"),
-		openCode: { available: openCodeInstalled() && readConfig().enabledProviders.opencode }
+		openCode: { available: openCodeInstalled() && readConfig().opencode.enabled }
 	};
 }
 function disabledAccount(account) {
@@ -4772,23 +4897,20 @@ async function publishAccounts() {
 async function capabilities(provider, accountId, cwd) {
 	assertEnabled(provider, accountId);
 	const result = await providerCapabilities(provider, accountId, cwd);
-	const settings = readConfig().models[provider];
+	const settings = readConfig()[provider].models;
 	return {
 		...result,
 		defaultModel: defaultModels[provider],
 		models: result.models.map((model) => {
 			const deprecated = deprecatedModels[provider].includes(model.value);
-			const setting = settings[model.value] ?? {
-				hidden: deprecated,
-				effort: null
-			};
+			const setting = settings[model.value] ?? { hidden: deprecated };
 			const preferred = defaultEfforts[provider];
 			const effort = preferred === null ? null : model.efforts.includes(preferred) ? preferred : model.efforts.at(-1) ?? null;
 			return {
 				...model,
 				deprecated,
 				hidden: setting.hidden,
-				effort: setting.effort ?? effort
+				effort
 			};
 		})
 	};
@@ -4805,51 +4927,80 @@ function providerCapabilities(provider, accountId, cwd) {
 function addAccount(provider, name, configDir) {
 	const account = validAccount(name, configDir);
 	const config = readConfig();
-	const key = `${provider}Accounts`;
 	saveConfig({
 		...config,
-		[key]: [...config[key], {
-			id: randomUUID(),
-			provider,
-			name: account.name,
-			color: null,
-			configDir: { [platform()]: account.configDir },
-			enabled: true
-		}]
+		[provider]: {
+			...config[provider],
+			accounts: [...config[provider].accounts, {
+				id: randomUUID(),
+				provider,
+				name: account.name,
+				color: null,
+				configDir: { [platform()]: account.configDir },
+				enabled: true
+			}]
+		}
 	});
+	publishAccounts();
+	return null;
 }
 async function updateAccount(update) {
 	const before = storedAccounts().find((item) => item.id === update.id);
 	if (before === void 0) throw new Error("That account was removed");
 	const account = validAccount(update.name, update.configDir);
 	const config = readConfig();
-	const key = `${before.provider}Accounts`;
 	saveConfig({
 		...config,
-		[key]: config[key].map((item) => item.id === update.id ? {
-			...item,
-			name: account.name,
-			color: update.color,
-			configDir: {
-				...item.configDir,
-				[platform()]: account.configDir
-			},
-			enabled: update.enabled
-		} : item)
+		[before.provider]: {
+			...config[before.provider],
+			accounts: config[before.provider].accounts.map((item) => item.id === update.id ? {
+				...item,
+				name: account.name,
+				color: update.color,
+				configDir: {
+					...item.configDir,
+					[platform()]: account.configDir
+				},
+				enabled: update.enabled
+			} : item)
+		}
 	});
 	forgetClaude(update.id);
 	forgetUsage(update.id);
 	if (before.enabled && !update.enabled) await stopAccount(before);
+	publishAccounts();
+	return null;
+}
+function accountLinkPlan(id) {
+	return linkPlan(storedAccount("claude", id).configDir ?? claudeBaseDir());
+}
+async function linkAccount(id) {
+	const account = storedAccount("claude", id);
+	await stopAccount(account);
+	try {
+		await linkClaude(account.configDir ?? claudeBaseDir());
+	} finally {
+		publishAccounts();
+	}
+	return null;
 }
 function removeAccount(id) {
 	const config = readConfig();
 	saveConfig({
 		...config,
-		claudeAccounts: config.claudeAccounts.filter((item) => item.id !== id),
-		codexAccounts: config.codexAccounts.filter((item) => item.id !== id)
+		claude: {
+			...config.claude,
+			accounts: config.claude.accounts.filter((item) => item.id !== id)
+		},
+		codex: {
+			...config.codex,
+			accounts: config.codex.accounts.filter((item) => item.id !== id)
+		}
 	});
 	forgetClaude(id);
 	forgetUsage(id);
+	publishAccounts();
+	return null;
 }
 function validAccount(name, configDir) {
 	if (name.trim() === "") throw new Error("Give the account a name");
@@ -4984,6 +5135,213 @@ 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/links.ts
+const run$3 = promisify(execFile);
+const requiredFolders = [
+	"projects",
+	"file-history",
+	"tasks",
+	"todos",
+	"plans",
+	"paste-cache",
+	"session-env",
+	"jobs",
+	"teams",
+	"sessions"
+];
+const sharedFolders = [
+	"skills",
+	"agents",
+	"commands",
+	"output-styles",
+	"plugins",
+	"cache",
+	"state",
+	"shell-snapshots"
+];
+const sharedFiles = [
+	"settings.json",
+	"CLAUDE.md",
+	"keybindings.json",
+	"history.jsonl"
+];
+function isLinked(configDir) {
+	const base = claudeBaseDir();
+	return sameFile(configDir, base) || requiredFolders.every((name) => sameFile(path.join(configDir, name), path.join(base, name)));
+}
+function linkPlan(configDir) {
+	const base = path.resolve(claudeBaseDir());
+	const dir = statSync(configDir, { throwIfNoEntry: false });
+	if (dir === void 0 || !dir.isDirectory()) throw new Error(`${configDir} does not exist`);
+	if (sameFile(configDir, base)) throw new Error(`${configDir} is the main Claude folder`);
+	return {
+		configDir,
+		baseDir: base,
+		entries: [
+			...requiredFolders.map((name) => entry(configDir, base, name, true, true)),
+			...sharedFolders.map((name) => entry(configDir, base, name, false, true)),
+			...sharedFiles.map((name) => entry(configDir, base, name, false, false))
+		]
+	};
+}
+async function linkClaude(configDir) {
+	const plan = linkPlan(configDir);
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replaceAll(":", "-");
+	const steps = plan.entries.flatMap((item) => entrySteps(plan, item, stamp));
+	if (steps.length === 0) return;
+	for (const item of plan.entries) if (item.createInBase) mkdirSync(path.join(plan.baseDir, item.name), { recursive: true });
+	if (process.platform === "win32" && !canSymlink()) await runElevated(steps);
+	else for (const step of steps) runStep(step);
+	const missing = plan.entries.filter((item) => item.action !== "skip" && !sameFile(path.join(plan.configDir, item.name), path.join(plan.baseDir, item.name)));
+	if (missing.length > 0) throw new Error(`Could not link ${missing.map((item) => item.name).join(", ")}`);
+}
+function entry(configDir, base, name, required, folder) {
+	const target = path.join(configDir, name);
+	const source = path.join(base, name);
+	const sourceExists = statSync(source, { throwIfNoEntry: false }) !== void 0;
+	return {
+		name,
+		required,
+		folder,
+		action: entryAction(target, source, folder, sourceExists),
+		createInBase: folder && !sourceExists
+	};
+}
+function entryAction(target, source, folder, sourceExists) {
+	if (!folder && !sourceExists) return "skip";
+	const existing = lstatSync(target, { throwIfNoEntry: false });
+	if (existing === void 0) return "link";
+	if (sameFile(target, source)) return "linked";
+	if (existing.isSymbolicLink()) return "relink";
+	if (existing.isDirectory() && readdirSync(target).length === 0) return "replace";
+	return "backup";
+}
+function entrySteps(plan, item, stamp) {
+	const target = path.join(plan.configDir, item.name);
+	const link = {
+		type: "link",
+		path: target,
+		target: path.join(plan.baseDir, item.name),
+		folder: item.folder
+	};
+	switch (item.action) {
+		case "linked":
+		case "skip": return [];
+		case "link": return [link];
+		case "relink": return [{
+			type: "unlink",
+			path: target
+		}, link];
+		case "replace": return [{
+			type: "rmdir",
+			path: target
+		}, link];
+		case "backup": {
+			const backup = `${target}.backup-${stamp}`;
+			if (lstatSync(backup, { throwIfNoEntry: false }) !== void 0) throw new Error(`${backup} already exists`);
+			return [{
+				type: "move",
+				from: target,
+				to: backup
+			}, link];
+		}
+	}
+}
+function sameFile(first, second) {
+	const firstStats = statSync(first, {
+		bigint: true,
+		throwIfNoEntry: false
+	});
+	const secondStats = statSync(second, {
+		bigint: true,
+		throwIfNoEntry: false
+	});
+	if (firstStats === void 0 || secondStats === void 0) return false;
+	return firstStats.dev === secondStats.dev && firstStats.ino === secondStats.ino;
+}
+function canSymlink() {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "offsite-"));
+	const link = path.join(dir, "link");
+	try {
+		symlinkSync(dir, link, "dir");
+	} catch (error) {
+		rmdirSync(dir);
+		if (error.code === "EPERM") return false;
+		throw error;
+	}
+	unlinkSync(link);
+	rmdirSync(dir);
+	return true;
+}
+function runStep(step) {
+	switch (step.type) {
+		case "unlink":
+			unlinkSync(step.path);
+			return;
+		case "rmdir":
+			rmdirSync(step.path);
+			return;
+		case "move":
+			renameSync(step.from, step.to);
+			return;
+		case "link": symlinkSync(step.target, step.path, step.folder ? "dir" : "file");
+	}
+}
+async function runElevated(steps) {
+	const user = await run$3("whoami", [
+		"/user",
+		"/fo",
+		"csv",
+		"/nh"
+	]);
+	const sid = user.stdout.trim().split(",").at(-1)?.replaceAll("\"", "");
+	if (sid === void 0 || !sid.startsWith("S-1-")) throw new Error(`Could not read your Windows user: ${user.stdout}`);
+	const owner = `*${sid}`;
+	const dir = mkdtempSync(path.join(os.tmpdir(), "offsite-"));
+	const errorFile = path.join(dir, "error.txt");
+	const script = `const fs = require('node:fs')
+const childProcess = require('node:child_process')
+const data = ${JSON.stringify({
+		steps,
+		owner,
+		errorFile
+	})}
+try {
+  for (const step of data.steps) {
+    if (step.type === 'unlink') fs.unlinkSync(step.path)
+    if (step.type === 'rmdir') fs.rmdirSync(step.path)
+    if (step.type === 'move') fs.renameSync(step.from, step.to)
+    if (step.type === 'link') {
+      fs.symlinkSync(step.target, step.path, step.folder ? 'dir' : 'file')
+      childProcess.execFileSync('icacls', [step.path, '/setowner', data.owner, '/L', '/Q'])
+    }
+  }
+} catch (error) {
+  fs.writeFileSync(data.errorFile, error.message)
+  process.exit(1)
+}`;
+	const code = `eval(Buffer.from('${Buffer.from(script).toString("base64")}','base64').toString())`;
+	try {
+		await run$3("powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`$ProgressPreference = 'SilentlyContinue'; try { $process = Start-Process -FilePath ${quote(process.execPath)} -ArgumentList '-e',${quote(code)} -Verb RunAs -WindowStyle Hidden -Wait -PassThru -ErrorAction Stop } catch { [Console]::Error.WriteLine($_.Exception.Message); exit 1 }; exit $process.ExitCode`
+		]);
+	} catch (error) {
+		if (existsSync(errorFile)) throw new Error(readFileSync(errorFile, "utf8"));
+		if (error instanceof Error && "stderr" in error && typeof error.stderr === "string" && error.stderr.trim() !== "") throw new Error(`Windows admin permission failed: ${error.stderr.trim()}`);
+		throw error;
+	} finally {
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function quote(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
 // src/lib/claude/claude.ts
 const log$8 = logger.withTag("claude");
 const efforts = [
@@ -5093,7 +5451,8 @@ function runOptions(options) {
 		...settings.model === null ? {} : { model: settings.model },
 		...settings.effort === null ? {} : { effort: claudeEffort(settings.effort) },
 		allowDangerouslySkipPermissions: true,
-		includePartialMessages: true
+		includePartialMessages: true,
+		perTaskStopAffordance: true
 	};
 }
 async function claudeCapabilities(account, cwd) {
@@ -5242,16 +5601,6 @@ function claudeLogin(configDir) {
 		} : null
 	};
 }
-function isLinked(configDir) {
-	const base = claudeBaseDir();
-	try {
-		if (realpathSync(configDir) === realpathSync(base)) return true;
-		return realpathSync(path.join(configDir, "projects")) === realpathSync(path.join(base, "projects"));
-	} catch (error) {
-		if (error.code === "ENOENT") return false;
-		throw error;
-	}
-}
 function initialization(accountId, cwd) {
 	const key = `${accountId}\n${cwd}`;
 	const existing = probes.get(key);
@@ -5812,10 +6161,18 @@ async function image(sessionId, uuid, index) {
 		data: block.data
 	};
 }
+async function shownMessages(sessionId, cwd) {
+	const [disk, session] = await Promise.all([getSessionMessages(sessionId, { dir: cwd }), loadSession(sessionId)]);
+	const found = runs.get(sessionId);
+	const saved = session?.entries.findLast((entry) => entry.type === "last-prompt" && entry.rewound === true);
+	const cuts = [found?.provider === "claude" ? found.cut : null, saved?.cutUuid];
+	const index = disk.findIndex((item) => cuts.includes(item.uuid));
+	return index < 0 ? disk : disk.slice(0, index);
+}
 async function history$1(sessionId, cwd) {
 	const found = runs.get(sessionId);
 	const run = found?.provider === "claude" ? found : void 0;
-	const [disk, session] = await Promise.all([getSessionMessages(sessionId, { dir: cwd }), loadSession(sessionId)]);
+	const [disk, session] = await Promise.all([shownMessages(sessionId, cwd), loadSession(sessionId)]);
 	const entries = session === null ? [] : session.entries;
 	const resumeAt = run?.resumeAt ?? null;
 	const kept = resumeAt === null ? disk : disk.slice(0, disk.findIndex((item) => item.uuid === resumeAt) + 1);
@@ -5858,6 +6215,28 @@ async function agentMessages(sessionId, cwd, agentId, parent) {
 		parent_tool_use_id: parent
 	}, null)]));
 }
+// src/lib/claude/permission.ts
+function permissionResult(input, suggestions, decision, answers) {
+	switch (decision) {
+		case "allow": return {
+			behavior: "allow",
+			updatedInput: answers === null ? input : {
+				...input,
+				answers
+			}
+		};
+		case "always": return {
+			behavior: "allow",
+			updatedInput: input,
+			updatedPermissions: suggestions
+		};
+		case "deny": return {
+			behavior: "deny",
+			message: "The user rejected this action",
+			interrupt: true
+		};
+	}
+}
 // src/lib/claude/run.ts
 const IDLE_LIMIT = 6e5;
 var Run = class {
@@ -5870,6 +6249,7 @@ var Run = class {
 	query;
 	closed;
 	resumeAt;
+	cut = null;
 	queue = [];
 	settings;
 	context = null;
@@ -5880,6 +6260,8 @@ var Run = class {
 	compacting = false;
 	backgroundTasks = 0;
 	backgroundAgents = 0;
+	agentTasks = 0;
+	failed = false;
 	tasks = {};
 	inbox = [];
 	wake = null;
@@ -5952,30 +6334,7 @@ var Run = class {
 	respond(requestId, decision, answers) {
 		const pending = this.pending.get(requestId);
 		if (pending === void 0) return;
-		const input = pending.input;
-		switch (decision) {
-			case "allow":
-				this.settle(requestId, {
-					behavior: "allow",
-					updatedInput: answers === null ? input : {
-						...input,
-						answers
-					}
-				});
-				return;
-			case "always":
-				this.settle(requestId, {
-					behavior: "allow",
-					updatedInput: input,
-					updatedPermissions: pending.suggestions
-				});
-				return;
-			case "deny": this.settle(requestId, {
-				behavior: "deny",
-				message: "The user rejected this action",
-				interrupt: true
-			});
-		}
+		this.settle(requestId, permissionResult(pending.input, pending.suggestions, decision, answers));
 	}
 	stop() {
 		this.stopping = true;
@@ -6069,7 +6428,9 @@ var Run = class {
 				return;
 			}
 			case "result": {
-				if (message.subtype !== "success" && message.terminal_reason !== "aborted_streaming" && message.terminal_reason !== "aborted_tools") this.add(notice(message.errors.filter((error) => !error.startsWith("[ede_diagnostic]")).join("\n") || message.subtype));
+				const failure = resultNotice(message);
+				if (failure !== null) this.add(failure);
+				this.failed = turnFailed(message);
 				this.finishTurn();
 				const usage = this.model === null ? void 0 : message.modelUsage[this.model];
 				if (this.context !== null && usage !== void 0) this.context = {
@@ -6091,6 +6452,7 @@ var Run = class {
 					});
 					return;
 				case "background_tasks_changed": {
+					this.agentTasks = message.tasks.filter((task) => task.task_type !== "local_bash").length;
 					const live = message.tasks.filter((task) => task.ambient !== true);
 					this.backgroundTasks = live.length;
 					this.backgroundAgents = live.filter((task) => task.task_type === "local_agent").length;
@@ -6237,6 +6599,30 @@ var Run = class {
 		});
 	}
 };
+// src/lib/claude/rewind.ts
+const ATTEMPTS = 10;
+const answerSchema = z.object({ response: z.discriminatedUnion("rewound", [z.object({ rewound: z.literal(true) }), z.object({
+	rewound: z.literal(false),
+	reason: z.string(),
+	error: z.string()
+})]) });
+async function rewindLive(run, messageId, lastSeenId) {
+	const request = Reflect.get(run.query, "request");
+	if (typeof request !== "function") throw new Error("This Claude Code version cannot rewind a live session");
+	for (let attempt = 1;; attempt++) {
+		const answer = answerSchema.parse(await Reflect.apply(request, run.query, [{
+			subtype: "rewind_conversation",
+			target_message_uuid: messageId,
+			last_seen_user_message_uuid: lastSeenId
+		}])).response;
+		if (answer.rewound) break;
+		if (answer.reason !== "turn_running" || attempt === ATTEMPTS) throw new Error(`Claude Code could not rewind: ${answer.error}`);
+		await setTimeout$1(500);
+	}
+	const index = run.messages.findIndex((item) => item.uuid === messageId);
+	run.messages.splice(index < 0 ? 0 : index);
+	run.cut = messageId;
+}
 // src/lib/proxy/sites.ts
 const sites = /* @__PURE__ */ new Map();
 const siteNames = /* @__PURE__ */ new Map();
@@ -6381,6 +6767,13 @@ function sessionHistory(sessionId, cwd) {
 		case "opencode": return openCodeHistory(sessionId, cwd);
 	}
 }
+function agentHistory(sessionId, cwd, agentId, parent) {
+	switch (providerOf(sessionId)) {
+		case "claude": return agentMessages(sessionId, cwd, agentId, parent);
+		case "codex": return codexAgent(agentId, parent);
+		case "opencode": return openCodeAgent(agentId, parent);
+	}
+}
 function rewind(request) {
 	return locked(request.sessionId, () => rewindNow(request));
 }
@@ -6388,7 +6781,6 @@ async function rewindNow(request) {
 	const sessionId = request.sessionId;
 	const cwd = projectPath(request.projectId);
 	if (runs.get(sessionId)?.running === true) throw new Error(`Stop ${providerName(providerOf(sessionId))} before rewinding`);
-	if ((runs.get(sessionId)?.backgroundTasks ?? 0) > 0) throw new Error("Wait for background tasks to finish before rewinding");
 	const run = await runFor(sessionId, cwd, request.settings);
 	if (run.provider === "codex") {
 		if (request.code) throw new Error("Codex cannot restore files");
@@ -6418,9 +6810,16 @@ async function rewindNow(request) {
 		};
 	}
 	if (request.dryRun || !request.conversation) return result;
-	const disk = await getSessionMessages(sessionId, { dir: cwd });
+	const disk = await shownMessages(sessionId, cwd);
 	const index = disk.findIndex((item) => item.uuid === request.messageId);
 	if (index < 1) throw new Error("Cannot rewind the conversation to that point");
+	if (run.backgroundTasks > 0) {
+		const lastSeen = disk.findLast((item) => item.type === "user" && item.parent_tool_use_id === null);
+		if (lastSeen === void 0) throw new Error("Cannot rewind the conversation to that point");
+		await rewindLive(run, request.messageId, lastSeen.uuid);
+		publish$2(sessionId, await history$1(sessionId, cwd));
+		return result;
+	}
 	run.stop();
 	await run.closed;
 	new Run({
@@ -6433,6 +6832,24 @@ async function rewindNow(request) {
 	publish$2(sessionId, await history$1(sessionId, cwd));
 	return result;
 }
+function restart(sessionId) {
+	return locked(sessionId, async () => {
+		const run = runs.get(sessionId);
+		if (run === void 0) return;
+		if (run.provider !== "claude") throw new Error("Only Claude Code threads can be restarted");
+		if (run.running) await run.interrupt();
+		run.stop();
+		await run.closed;
+		new Run({
+			sessionId,
+			cwd: run.cwd,
+			resume: true,
+			resumeAt: null,
+			settings: run.settings
+		});
+		publish$2(sessionId, await history$1(sessionId, run.cwd));
+	});
+}
 async function open$1(client, sessionId, projectId) {
 	client.opening = sessionId;
 	const event = await sessionHistory(sessionId, projectPath(projectId));
@@ -6471,7 +6888,7 @@ async function submitFirst(client, run, request, projectId) {
 		from: request.projectId
 	});
 	await run.submit(request.prompt, request.delivery);
-	recordInteraction(sessionId, run.provider);
+	recordInteraction(sessionId, run.provider, request.status);
 }
 async function sendExisting(client, sessionId, cwd, request) {
 	const provider = providerOf(sessionId);
@@ -6485,7 +6902,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, provider);
+	recordInteraction(sessionId, provider, request.status);
 	if (emptied.has(sessionId) && request.prompt.text.trim() !== "") {
 		emptied.delete(sessionId);
 		await updateSession(sessionId, { title: request.prompt.text.trim() });
@@ -6535,7 +6952,7 @@ async function startRun(cwd, settings) {
 }
 async function changedElsewhere(run, cwd) {
 	if (run.messages.length === 0) return false;
-	const last = (await getSessionMessages(run.sessionId, { dir: cwd })).at(-1)?.uuid;
+	const last = (await shownMessages(run.sessionId, cwd)).at(-1)?.uuid;
 	return last !== void 0 && !run.messages.some((item) => item.uuid === last);
 }
 // src/services/export.ts
@@ -6675,7 +7092,7 @@ async function searchMessages(query) {
 		"claude",
 		"codex",
 		"opencode"
-	].filter((provider) => readConfig().enabledProviders[provider]).map(async (provider) => {
+	].filter((provider) => readConfig()[provider].enabled).map(async (provider) => {
 		try {
 			return {
 				provider,
@@ -8064,6 +8481,15 @@ const lastUsedSchema = z.discriminatedUnion("provider", [z.strictObject({
 	accountId: z.null(),
 	model: z.string()
 })]);
+const lastEffortSchema = z.strictObject({
+	provider: z.enum([
+		"claude",
+		"codex",
+		"opencode"
+	]),
+	model: z.string(),
+	effort: z.string().nullable()
+});
 function readLastUsed() {
 	return db.select().from(lastUsedModels).all();
 }
@@ -8084,6 +8510,22 @@ function saveLastUsed(value) {
 	});
 	return null;
 }
+function readLastEfforts() {
+	return db.select().from(lastEfforts).all();
+}
+function saveLastEffort(value) {
+	const result = lastEffortSchema.safeParse(value);
+	if (!result.success) throw new Error(z.prettifyError(result.error));
+	db.insert(lastEfforts).values(result.data).onConflictDoUpdate({
+		target: [lastEfforts.provider, lastEfforts.model],
+		set: { effort: result.data.effort }
+	}).run();
+	broadcast({
+		type: "lastEfforts",
+		lastEfforts: readLastEfforts()
+	});
+	return null;
+}
 // ../core/src/app-icons.ts
 const appIcons = [
 	{
@@ -8184,6 +8626,7 @@ const handlers = {
 		return {
 			...configInfo(),
 			lastUsed: readLastUsed(),
+			lastEfforts: readLastEfforts(),
 			hostname: os.hostname(),
 			projects: projects(),
 			sessions: sessions(),
@@ -8195,6 +8638,7 @@ const handlers = {
 	},
 	"config.get": () => configInfo(),
 	"lastUsed.save": (params) => saveLastUsed(params),
+	"lastEffort.save": (params) => saveLastEffort(params),
 	"appIcon.save": (params) => saveAppIcon(params),
 	"config.save": async (params) => {
 		const before = readConfig();
@@ -8203,8 +8647,8 @@ const handlers = {
 			"claude",
 			"codex",
 			"opencode"
-		]) if (before.enabledProviders[provider] && !saved.enabledProviders[provider]) await stopProvider(provider);
-		if (JSON.stringify(saved.claudeBaseDir) === JSON.stringify(before.claudeBaseDir) && JSON.stringify(saved.enabledProviders) === JSON.stringify(before.enabledProviders)) return saved;
+		]) if (before[provider].enabled && !saved[provider].enabled) await stopProvider(provider);
+		if (JSON.stringify(saved.claude.baseDir) === JSON.stringify(before.claude.baseDir) && saved.claude.enabled === before.claude.enabled && saved.codex.enabled === before.codex.enabled && saved.opencode.enabled === before.opencode.enabled) return saved;
 		watchSessions();
 		refreshAll();
 		publishAccounts();
@@ -8256,13 +8700,7 @@ const handlers = {
 	"sessions.earlier": (params) => earlier(params.sessionId, params.before),
 	"sessions.export": (params) => exportSession(params.sessionId, params.projectId),
 	"sessions.image": (params) => image(params.sessionId, params.itemId, params.index),
-	"sessions.agent": (params) => {
-		switch (providerOf(params.sessionId)) {
-			case "claude": return agentMessages(params.sessionId, projectPath(params.projectId), params.agentId, params.parent);
-			case "codex": return codexAgent(params.agentId, params.parent);
-			case "opencode": return openCodeAgent(params.agentId, params.parent);
-		}
-	},
+	"sessions.agent": (params) => agentHistory(params.sessionId, projectPath(params.projectId), params.agentId, params.parent),
 	"sessions.send": async (params, client) => {
 		await send$1(client, params);
 		return null;
@@ -8279,6 +8717,10 @@ const handlers = {
 		await runs.get(params.sessionId)?.interrupt();
 		return null;
 	},
+	"sessions.restart": async (params) => {
+		await restart(params.sessionId);
+		return null;
+	},
 	"sessions.stopTask": async (params) => {
 		await runs.get(params.sessionId)?.stopTask(params.taskId);
 		return null;
@@ -8291,7 +8733,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, run.provider);
+		recordInteraction(params.sessionId, run.provider, null);
 		return null;
 	},
 	"sessions.rewind": (params) => rewind(params),
@@ -8301,21 +8743,11 @@ const handlers = {
 		return result;
 	},
 	"accounts.list": () => accounts(),
-	"accounts.add": (params) => {
-		addAccount(params.provider, params.name, params.configDir);
-		publishAccounts();
-		return null;
-	},
-	"accounts.update": async (params) => {
-		await updateAccount(params);
-		publishAccounts();
-		return null;
-	},
-	"accounts.remove": (params) => {
-		removeAccount(params.id);
-		publishAccounts();
-		return null;
-	},
+	"accounts.add": (params) => addAccount(params.provider, params.name, params.configDir),
+	"accounts.update": (params) => updateAccount(params),
+	"accounts.remove": (params) => removeAccount(params.id),
+	"accounts.link": (params) => linkAccount(params.id),
+	"accounts.linkPlan": (params) => accountLinkPlan(params.id),
 	"accounts.usage": (params) => readUsage(params.id, params.force),
 	capabilities: (params) => capabilities(params.provider, params.accountId, params.projectId === null || params.projectId === "no-project" ? os.homedir() : projectPath(params.projectId)),
 	"files.list": (params) => params.projectId === "no-project" ? [] : listFiles(projectPath(params.projectId)),
@@ -9700,7 +10132,7 @@ 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]);
+	const enabled = allProviders.filter((provider) => readConfig()[provider].enabled);
 	for (const row of rows) {
 		const answers = await Promise.all(enabled.map(async (provider) => {
 			try {