@treeport/treeport 0.4.0 → 0.5.0

package/dist/node/server/index.js

@@ -1,4 +1,4 @@
-import { $ as terminalTakeControlSchema, B as TERMINAL_SELECTION_CLEAR_SEQUENCE, C as repositoryTerminalPresetsFileSchema, D as updateTerminalPresetSchema, E as updateProjectSchema, G as parseTerminalProgress, H as TERMINAL_SELECTION_START_SEQUENCE, J as terminalInputSchema, K as terminalBellAcknowledgementSchema, M as SOCKET_IO_PATH, N as TERMINAL_CONTROLLER_GRACE_MS, O as updateTerminalSchema, P as TERMINAL_MAX_CLIENT_MESSAGE_BYTES, Q as terminalSizeSchema, R as TERMINAL_OUTPUT_STALL_TIMEOUT_MS, S as repositoryTerminalPresetSchema, T as terminalCaptureQuerySchema, U as TERMINAL_SELECTION_STOP_SEQUENCE, V as TERMINAL_SELECTION_RESTORE_SEQUENCE, W as parseTerminalAuth, X as terminalOutputAckSchema, Y as terminalLegacyTakeControlSchema, Z as terminalResizeSchema, _ as packageReloadSchema, b as registerProjectSchema, c as createTerminalSchema, d as deleteTerminalPresetSchema, f as deleteWebPanelStorageSchema, g as packageProjectQuerySchema, h as packageInstallSchema, i as TERMINAL_MAX_UPLOAD_BYTES, k as webPanelInputSchema, l as createWebPanelSchema, m as openWebPanelSchema, n as parseDurationMs, o as browseDirectoryQuerySchema, p as getWebPanelStorageSchema, q as terminalBinarySchema, s as createTerminalPresetSchema, t as assertLoopbackHost, u as createWorktreeSchema, v as packageRemoveSchema, w as setWebPanelStorageSchema, x as removeWorktreeSchema, y as packageUpdateSchema, z as TERMINAL_SCROLL_EXIT_SEQUENCE } from "../../loopback-D7k_J_Wl.js";
+import { $ as repositoryTerminalPresetSchema, At as terminalSizeSchema, B as createWorktreeSchema, Ct as parseTerminalProgress, Dt as terminalLegacyTakeControlSchema, Et as terminalInputSchema, G as openWebPanelSchema, H as deleteWebPanelStorageSchema, I as browseDirectoryQuerySchema, J as packageReloadSchema, K as packageInstallSchema, L as createTerminalPresetSchema, M as parseDurationMs, Ot as terminalOutputAckSchema, P as TERMINAL_MAX_UPLOAD_BYTES, Q as removeWorktreeSchema, R as createTerminalSchema, St as parseTerminalAuth, Tt as terminalBinarySchema, U as formatCommandLine, V as deleteTerminalPresetSchema, W as getWebPanelStorageSchema, X as packageUpdateSchema, Y as packageRemoveSchema, Z as registerProjectSchema, _ as serviceStatus, _t as TERMINAL_SCROLL_EXIT_SEQUENCE, a as readLocalUpdateProgress, at as updateTerminalPresetSchema, bt as TERMINAL_SELECTION_START_SEQUENCE, c as createUpdateStartupReporter, dt as TERMINAL_CONTROLLER_GRACE_MS, et as repositoryTerminalPresetsFileSchema, ft as TERMINAL_MAX_CLIENT_MESSAGE_BYTES, gt as TERMINAL_OUTPUT_STALL_TIMEOUT_MS, i as isCanonicalTreeportVersion, it as updateProjectSchema, j as assertLoopbackHost, jt as terminalTakeControlSchema, kt as terminalResizeSchema, n as compareTreeportVersions, nt as setWebPanelStorageSchema, o as resolveLatestTreeportRelease, ot as updateTerminalSchema, q as packageProjectQuerySchema, r as inspectLocalUpdateInstallation, rt as terminalCaptureQuerySchema, st as webPanelInputSchema, tt as requestWorkspaceOpenSchema, ut as SOCKET_IO_PATH, vt as TERMINAL_SELECTION_CLEAR_SEQUENCE, wt as terminalBellAcknowledgementSchema, xt as TERMINAL_SELECTION_STOP_SEQUENCE, yt as TERMINAL_SELECTION_RESTORE_SEQUENCE, z as createWebPanelSchema } from "../../update-BW-a6Bd-.js";
 import { n as prepareShellIntegration } from "../../shell-integration-Be_c91lw.js";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -113,11 +113,17 @@ var ExternalCommandError = class extends Data.TaggedError("ExternalCommandError"
 function errorMessage$1(cause) {
 	return cause instanceof Error ? cause.message : String(cause);
 }
+function signalProcessGroup(processGroupId, signal) {
+	try {
+		process.kill(-processGroupId, signal);
+	} catch (cause) {
+		if (cause.code !== "ESRCH") throw cause;
+	}
+}
 /**
-* Runs a child command as an interruptible Effect. The child is acquired as a
-* resource, so interruption completes only after the finalizer has sent
-* SIGTERM, escalated to SIGKILL when needed, and observed the direct child
-* exit. Descendant process groups are intentionally outside this contract.
+* Runs a child command as an interruptible Effect. The child is acquired in an
+* isolated process group, so interruption completes only after the finalizer
+* has signaled the full group and observed the direct child exit.
 */
 function runCommandEffect(request) {
 	const stdoutLimit = request.maxStdoutBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
@@ -134,7 +140,8 @@ function runCommandEffect(request) {
 					"pipe",
 					"pipe"
 				],
-				shell: false
+				shell: false,
+				detached: true
 			});
 		} catch (cause) {
 			resume(Effect.fail(new SpawnCommandError(request, cause)));
@@ -157,6 +164,7 @@ function runCommandEffect(request) {
 			child.removeListener("spawn", onSpawn);
 			resume(Effect.succeed({
 				child,
+				processGroupId: child.pid,
 				exit,
 				onExit,
 				onProcessError,
@@ -249,16 +257,13 @@ function runCommandEffect(request) {
 			resource.terminalError ??= new TimeoutCommandError(request, timeoutMs);
 			return resource.terminalError;
 		})), Effect.flatMap(Effect.fail)));
-	}, (resource) => Deferred.isDone(resource.exit).pipe(Effect.flatMap((alreadyExited) => {
-		if (alreadyExited) return Effect.void;
+	}, (resource, useExit) => Deferred.isDone(resource.exit).pipe(Effect.flatMap((alreadyExited) => {
+		if (alreadyExited && Exit.isSuccess(useExit)) return Effect.void;
 		return Effect.sync(() => {
-			resource.child.kill("SIGTERM");
-		}).pipe(Effect.zipRight(Effect.raceFirst(Deferred.await(resource.exit).pipe(Effect.as(true), Effect.interruptible), Effect.sleep(Duration.millis(killGraceMs)).pipe(Effect.as(false), Effect.interruptible))), Effect.flatMap((exited) => {
-			if (exited) return Effect.void;
-			return Effect.sync(() => {
-				resource.child.kill("SIGKILL");
-			}).pipe(Effect.zipRight(Deferred.await(resource.exit)));
-		}));
+			signalProcessGroup(resource.processGroupId, "SIGTERM");
+		}).pipe(Effect.zipRight(Effect.raceFirst(Deferred.await(resource.exit).pipe(Effect.as(true), Effect.interruptible), Effect.sleep(Duration.millis(killGraceMs)).pipe(Effect.as(false), Effect.interruptible))), Effect.flatMap((exited) => Effect.sync(() => {
+			signalProcessGroup(resource.processGroupId, "SIGKILL");
+		}).pipe(Effect.zipRight(exited ? Effect.void : Deferred.await(resource.exit)))));
 	}), Effect.ensuring(Effect.sync(() => {
 		resource.child.removeListener("exit", resource.onExit);
 		resource.child.removeListener("error", resource.onProcessError);
@@ -359,6 +364,7 @@ var database_schema_exports = /* @__PURE__ */ __exportAll({
 const projects = sqliteTable("projects", {
 	id: text().primaryKey(),
 	name: text().notNull(),
+	kind: text("project_kind", { enum: ["repository", "folder"] }).notNull().default("repository"),
 	repositoryPath: text("repository_path").notNull().unique(),
 	mainWorktreePath: text("main_worktree_path").notNull(),
 	defaultBranch: text("default_branch").notNull(),
@@ -368,15 +374,18 @@ const projects = sqliteTable("projects", {
 	repositoryInode: text("repository_inode").notNull(),
 	nameIsCustom: integer("name_is_custom").notNull().default(0),
 	isOpen: integer("is_open").notNull().default(1),
+	showInRecents: integer("show_in_recents").notNull().default(0),
 	lastOpenedAt: text("last_opened_at").notNull(),
 	createdAt: text("created_at").notNull(),
 	updatedAt: text("updated_at").notNull()
 }, (table) => [
+	check("projects_kind_check", sql`${table.kind} IN ('repository','folder')`),
 	check("projects_color_check", sql`${table.color} IS NULL OR ${table.color} IN ('rose','orange','amber','emerald','cyan','blue','violet','pink')`),
 	check("projects_name_is_custom_check", sql`${table.nameIsCustom} IN (0,1)`),
 	check("projects_is_open_check", sql`${table.isOpen} IN (0,1)`),
+	check("projects_show_in_recents_check", sql`${table.showInRecents} IN (0,1)`),
 	uniqueIndex("projects_repository_identity_idx").on(table.repositoryIdentity).where(sql`${table.repositoryIdentity} IS NOT NULL`),
-	index("projects_recent_idx").on(table.isOpen, desc(table.lastOpenedAt), table.id)
+	index("projects_recent_idx").on(table.isOpen, table.showInRecents, desc(table.lastOpenedAt), table.id)
 ]);
 const worktrees = sqliteTable("worktrees", {
 	id: text().primaryKey(),
@@ -405,7 +414,7 @@ const worktrees = sqliteTable("worktrees", {
 	check("worktrees_detached_check", sql`${table.detached} IN (0,1)`),
 	check("worktrees_locked_check", sql`${table.locked} IN (0,1)`),
 	check("worktrees_prunable_check", sql`${table.prunable} IN (0,1)`),
-	check("worktrees_kind_check", sql`${table.kind} IN ('main','linked')`),
+	check("worktrees_kind_check", sql`${table.kind} IN ('main','linked','folder')`),
 	index("worktrees_project_idx").on(table.projectId),
 	uniqueIndex("worktrees_git_key_idx").on(table.projectId, table.gitWorktreeKey).where(sql`${table.gitWorktreeKey} IS NOT NULL`)
 ]);
@@ -517,6 +526,7 @@ function normalizeWorktreeName(input) {
 }
 function inferWorktreeName(mainWorktreePath, worktreePath, kind) {
 	if (kind === "main") return "main tree";
+	if (kind === "folder") return path.basename(worktreePath);
 	const checkoutName = path.basename(worktreePath);
 	return checkoutName === path.basename(mainWorktreePath) ? path.basename(path.dirname(worktreePath)) : checkoutName;
 }
@@ -649,11 +659,8 @@ function resolveTask(task, input, protectCompatibilityEnvironment) {
 	const useShell = /[\s;&|<>`$()]/u.test(command);
 	return {
 		label: expand(task.label, compatibilityEnvironment),
-		argv: useShell ? [
-			input.shell,
-			"-lc",
-			[command, ...args.map(shellQuote)].join(" ")
-		] : [command, ...args],
+		argv: useShell ? null : [command, ...args],
+		shellCommand: useShell ? [command, ...args.map(shellQuote)].join(" ") : null,
 		cwd,
 		env: protectCompatibilityEnvironment ? {
 			...taskEnvironment,
@@ -712,8 +719,9 @@ async function loadZedTerminalPresetDefinitions(input) {
 		definitions.push({
 			id: `repository:${input.projectId}:zed-task:${index}`,
 			name: resolved.label,
-			executable: resolved.argv[0],
-			args: resolved.argv.slice(1),
+			executable: resolved.argv?.[0] ?? null,
+			args: resolved.argv?.slice(1) ?? [],
+			shellCommand: resolved.shellCommand,
 			cwd: resolved.cwd,
 			env: resolved.env,
 			closeOnSuccess: false,
@@ -731,9 +739,18 @@ async function loadZedTerminalPresetDefinitions(input) {
 async function resolveZedCreateWorktreeSetupTasks(input) {
 	return (await loadCreateWorktreeTasks(input.mainWorktreePath)).map((task) => {
 		const resolved = resolveTask(task, input, false);
+		let argv = resolved.argv;
+		if (!argv) {
+			if (!resolved.shellCommand) throw new Error(`Zed task ${task.label} has no resolved command`);
+			argv = [
+				input.shell,
+				"-lc",
+				resolved.shellCommand
+			];
+		}
 		return {
 			label: task.label,
-			argv: resolved.argv,
+			argv,
 			cwd: resolved.cwd,
 			env: resolved.env,
 			timeoutMs: 30 * 6e4
@@ -874,6 +891,8 @@ async function openDatabase(filePath, options = {}) {
 	const databaseExists = fsSync.existsSync(absoluteFilePath);
 	let hasDurableSchema = false;
 	let hasLegacyMigrations = false;
+	let migrationsPending = !databaseExists;
+	const migrationSnapshotPaths = [];
 	let drizzleRows = [];
 	if (!databaseExists) await fsSync.promises.mkdir(path.dirname(absoluteFilePath), {
 		recursive: true,
@@ -919,7 +938,8 @@ async function openDatabase(filePath, options = {}) {
 				if (!knownMigration || knownMigration.hash !== row.hash) throw new Error(`Treeport database at ${absoluteFilePath} has an unrecognized migration history. Use a compatible Treeport version or restore a pre-migration snapshot.`);
 			}
 			if (hasDurableSchema && !hasLegacyMigrations && drizzleRows.length === 0) throw new Error(`Treeport database at ${absoluteFilePath} has no recognized migration history; refusing to modify it.`);
-			if ((drizzleRows.length === 0 || Number(drizzleRows.at(-1)?.createdAt) < latestMigration.folderMillis) && hasDurableSchema) {
+			migrationsPending = drizzleRows.length === 0 || Number(drizzleRows.at(-1)?.createdAt) < latestMigration.folderMillis;
+			if (migrationsPending && hasDurableSchema) {
 				const backupDirectory = path.resolve(options.backupDirectory ?? path.join(path.dirname(absoluteFilePath), "database-backups"));
 				await fsSync.promises.mkdir(backupDirectory, {
 					recursive: true,
@@ -932,6 +952,7 @@ async function openDatabase(filePath, options = {}) {
 				try {
 					await db.run(sql.raw(`VACUUM INTO '${backupPath.replaceAll("'", "''")}'`));
 					await fsSync.promises.chmod(backupPath, 384);
+					migrationSnapshotPaths.push(backupPath);
 				} catch (error) {
 					await fsSync.promises.rm(backupPath, { force: true });
 					throw error;
@@ -965,6 +986,8 @@ async function openDatabase(filePath, options = {}) {
 		return {
 			filePath: absoluteFilePath,
 			db,
+			migrationState: migrationsPending ? "advanced" : "unchanged",
+			migrationSnapshotPaths,
 			close: () => client.close()
 		};
 	} catch (error) {
@@ -976,6 +999,8 @@ function mapProject(row, worktreeRows) {
 	return {
 		id: row.id,
 		name: row.name,
+		kind: row.kind,
+		rootPath: row.repositoryPath,
 		repositoryPath: row.repositoryPath,
 		mainWorktreePath: row.mainWorktreePath,
 		defaultBranch: row.defaultBranch,
@@ -995,7 +1020,7 @@ function mapWorktree(row, mainWorktreePath) {
 		projectId: row.projectId,
 		name: inferWorktreeName(mainWorktreePath, row.path, row.kind),
 		path: row.path,
-		head: row.head,
+		head: row.kind === "folder" ? "" : row.head,
 		branch: row.branch,
 		detached: Boolean(row.detached),
 		locked: Boolean(row.locked),
@@ -1284,10 +1309,34 @@ var GitAdapter = class {
 			timeoutMs: 3e4
 		});
 	}
+	async findRepositoryRoot(inputPath) {
+		const canonicalInput = await fs.realpath(path.resolve(inputPath));
+		const request = {
+			executable: this.executable,
+			args: ["rev-parse", "--show-toplevel"],
+			cwd: canonicalInput,
+			timeoutMs: 3e4
+		};
+		const result = await this.runner.run(request);
+		if (result.exitCode === 0) return fs.realpath(result.stdout.trim());
+		if (/not a git repository|outside repository/iu.test(result.stderr)) return null;
+		throw new ExternalCommandError(`Could not inspect Git repository state: ${result.stderr.trim() || `Git exited with code ${result.exitCode}`}`, request, result);
+	}
+	async findProjectRepositoryRoot(inputPath) {
+		const canonicalInput = await fs.realpath(path.resolve(inputPath));
+		const repositoryRoot = await this.findRepositoryRoot(canonicalInput);
+		if (!repositoryRoot || repositoryRoot === canonicalInput) return repositoryRoot;
+		return (await this.checked(repositoryRoot, [
+			"rev-list",
+			"--all",
+			"--max-count=1"
+		])).stdout.trim() ? repositoryRoot : null;
+	}
 	async canonicalizeRepositoryPath(inputPath) {
+		const repositoryRoot = await this.findRepositoryRoot(inputPath);
+		if (repositoryRoot) return repositoryRoot;
 		const canonicalInput = await fs.realpath(path.resolve(inputPath));
-		const result = await this.checked(canonicalInput, ["rev-parse", "--show-toplevel"]);
-		return fs.realpath(result.stdout.trim());
+		throw new Error(`Not a Git repository: ${canonicalInput}`);
 	}
 	async repositoryIdentityValues(cwd) {
 		const result = await this.runner.run({
@@ -2155,7 +2204,7 @@ var PackageSystem = class {
 		if (scope === "global") return path.join(this.config.dataDir, "settings.json");
 		const project = projectId ? this.projectContexts.get(projectId) : void 0;
 		if (!project) throw new DomainError("PROJECT_NOT_FOUND", "Project not found for package operation", 404);
-		return path.join(project.mainWorktreePath, ".treeport", "settings.json");
+		return path.join(project.rootPath, ".treeport", "settings.json");
 	}
 	async serialize(key, operation) {
 		const previous = this.operationTails.get(key) ?? Promise.resolve();
@@ -2312,7 +2361,7 @@ var PackageSystem = class {
 		};
 	}
 	npmRoot(scope, projectId) {
-		return scope === "global" ? path.join(this.config.dataDir, "npm") : path.join(this.projectContexts.get(projectId).mainWorktreePath, ".treeport", "npm");
+		return scope === "global" ? path.join(this.config.dataDir, "npm") : path.join(this.projectContexts.get(projectId).rootPath, ".treeport", "npm");
 	}
 	npmPackagePath(source, scope, projectId) {
 		return path.join(this.npmRoot(scope, projectId), "node_modules", source.name);
@@ -2628,6 +2677,7 @@ var PackageSystem = class {
 					name: result.data.name,
 					executable: result.data.executable,
 					args: [...result.data.args],
+					shellCommand: null,
 					cwd: null,
 					env: {},
 					closeOnSuccess: result.data.closeOnSuccess,
@@ -2878,7 +2928,7 @@ var PackageSystem = class {
 		return {
 			id: project.id,
 			name: project.name,
-			mainWorktreePath: project.mainWorktreePath
+			rootPath: project.rootPath
 		};
 	}
 	syncProjects(projects) {
@@ -2886,7 +2936,7 @@ var PackageSystem = class {
 			const next = this.context(project);
 			const previous = this.projectContexts.get(project.id);
 			this.projectContexts.set(project.id, next);
-			if (previous && (previous.mainWorktreePath !== next.mainWorktreePath || previous.name !== next.name)) this.projectFingerprints.delete(project.id);
+			if (previous && (previous.rootPath !== next.rootPath || previous.name !== next.name)) this.projectFingerprints.delete(project.id);
 		}
 	}
 	async initialize(projects) {
@@ -3210,6 +3260,7 @@ async function loadRepositoryTerminalPresets(projectId, worktreePath) {
 			name: preset.data.name,
 			executable: preset.data.executable,
 			args: [...preset.data.args],
+			shellCommand: null,
 			cwd: null,
 			env: {},
 			closeOnSuccess: preset.data.closeOnSuccess,
@@ -3826,6 +3877,7 @@ var TmuxAdapter = class {
 	uid;
 	creationTails = /* @__PURE__ */ new Map();
 	configuredSockets = /* @__PURE__ */ new Set();
+	socketConfigurationPromises = /* @__PURE__ */ new Map();
 	initializationPromise = null;
 	sshAuthSockPromise = null;
 	constructor(runner, runtimeDir, executable = "tmux", launcherPath, host = {}) {
@@ -3923,10 +3975,8 @@ var TmuxAdapter = class {
 					env: environment
 				};
 				if (input.fallbackArgv) spec.fallbackArgv = [...input.fallbackArgv];
-				if (shellIntegrationReady) {
-					spec.shellIntegrationDir = this.shellIntegrationDir;
-					spec.tmuxExecutable = resolveExecutablePath(this.executable, this.hostEnvironment);
-				}
+				spec.tmuxExecutable = resolveExecutablePath(this.executable, this.hostEnvironment);
+				if (shellIntegrationReady) spec.shellIntegrationDir = this.shellIntegrationDir;
 				if (input.setupTasks?.length) spec.setupTasks = input.setupTasks.map((task) => ({
 					...task,
 					argv: [...task.argv],
@@ -3965,6 +4015,8 @@ var TmuxAdapter = class {
 					worktreeId: input.worktreeId,
 					name: input.name,
 					argv: input.argv,
+					shellCommand: input.shellCommand,
+					interactiveShell: input.interactiveShell,
 					closeOnSuccess: input.closeOnSuccess ?? false,
 					createdAt: input.createdAt,
 					updatedAt: input.createdAt
@@ -3992,7 +4044,10 @@ var TmuxAdapter = class {
 		}
 	}
 	async configureServer(socketName) {
-		await runChecked(this.runner, {
+		if (this.configuredSockets.has(socketName)) return;
+		const existing = this.socketConfigurationPromises.get(socketName);
+		if (existing) return existing;
+		const configuring = runChecked(this.runner, {
 			executable: this.executable,
 			args: [
 				...this.base(socketName),
@@ -4001,13 +4056,20 @@ var TmuxAdapter = class {
 			],
 			env: this.environment(),
 			timeoutMs: 1e4
+		}).then(() => {
+			this.configuredSockets.add(socketName);
+		});
+		this.socketConfigurationPromises.set(socketName, configuring);
+		return configuring.finally(() => {
+			if (this.socketConfigurationPromises.get(socketName) === configuring) this.socketConfigurationPromises.delete(socketName);
 		});
-		this.configuredSockets.add(socketName);
 	}
 	async configureSession(socketName, sessionName, metadata) {
 		const values = [
 			["@treeport-name", encodeMetadata(metadata.name)],
 			["@treeport-argv", encodeMetadata(metadata.argv)],
+			["@treeport-shell-command", encodeMetadata(metadata.shellCommand)],
+			["@treeport-interactive-shell", metadata.interactiveShell ? "1" : "0"],
 			["@treeport-close-on-success", metadata.closeOnSuccess ? "1" : "0"],
 			["@treeport-created-at", encodeMetadata(metadata.createdAt)],
 			["@treeport-updated-at", encodeMetadata(metadata.updatedAt)],
@@ -4060,7 +4122,7 @@ var TmuxAdapter = class {
 				"list-panes",
 				"-a",
 				"-F",
-				"#{session_name}	#{@treeport-terminal-id}	#{@treeport-worktree-id}	#{@treeport-name}	#{@treeport-argv}	#{@treeport-close-on-success}	#{@treeport-created-at}	#{@treeport-updated-at}	#{session_created}	#{pane_dead}	#{pane_dead_status}"
+				"#{session_name}	#{@treeport-terminal-id}	#{@treeport-worktree-id}	#{@treeport-name}	#{@treeport-argv}	#{@treeport-shell-command}	#{@treeport-interactive-shell}	#{@treeport-close-on-success}	#{@treeport-created-at}	#{@treeport-updated-at}	#{session_created}	#{pane_dead}	#{pane_dead_status}"
 			],
 			env: this.environment(),
 			timeoutMs: 1e4
@@ -4072,7 +4134,7 @@ var TmuxAdapter = class {
 		const sessions = /* @__PURE__ */ new Map();
 		for (const line of result.stdout.split("\n")) {
 			if (!line) continue;
-			const [sessionName, terminalId, worktreeId, encodedName, encodedArgv, closeOnSuccess, encodedCreatedAt, encodedUpdatedAt, sessionCreated, paneDead, paneDeadStatus] = line.split("	");
+			const [sessionName, terminalId, worktreeId, encodedName, encodedArgv, encodedShellCommand, encodedInteractiveShell, closeOnSuccess, encodedCreatedAt, encodedUpdatedAt, sessionCreated, paneDead, paneDeadStatus] = line.split("	");
 			if (!sessionName || sessions.has(sessionName) || !terminalId || !worktreeId) continue;
 			let metadata;
 			try {
@@ -4081,12 +4143,15 @@ var TmuxAdapter = class {
 					worktreeId,
 					name: decodeMetadata(encodedName ?? "", z.string()),
 					argv: decodeMetadata(encodedArgv ?? "", z.array(z.string())),
+					shellCommand: decodeMetadata(encodedShellCommand ?? "", z.string().nullable()),
 					createdAt: decodeMetadata(encodedCreatedAt ?? "", z.string()),
 					updatedAt: decodeMetadata(encodedUpdatedAt ?? "", z.string())
 				};
 			} catch {
 				continue;
 			}
+			const interactiveShell = encodedInteractiveShell === "1" ? true : encodedInteractiveShell === "0" ? false : void 0;
+			if (metadata.shellCommand === void 0 || interactiveShell === void 0) continue;
 			const fallbackCreatedAt = metadata.createdAt ?? (/* @__PURE__ */ new Date(Number(sessionCreated) * 1e3)).toISOString();
 			const dead = paneDead === "1";
 			const exitCode = dead && paneDeadStatus ? Number.parseInt(paneDeadStatus, 10) : null;
@@ -4096,6 +4161,8 @@ var TmuxAdapter = class {
 				name: metadata.name ?? sessionName,
 				sessionName,
 				argv: metadata.argv ?? [],
+				shellCommand: metadata.shellCommand,
+				interactiveShell,
 				closeOnSuccess: closeOnSuccess === "1",
 				status: dead ? "exited" : "running",
 				exitCode: Number.isNaN(exitCode) ? null : exitCode,
@@ -4248,7 +4315,7 @@ var TmuxAdapter = class {
 				"-p",
 				"-t",
 				sessionName,
-				"#{@treeport-shell-title}	#{pane_current_command}	#{@treeport-command}	#{pane_title}"
+				"#{@treeport-fallback-shell}	#{@treeport-shell-title}	#{pane_current_command}	#{@treeport-command}	#{pane_title}"
 			],
 			env: this.environment(),
 			timeoutMs: 1e4
@@ -4257,19 +4324,22 @@ var TmuxAdapter = class {
 		const firstSeparator = result.stdout.indexOf("	");
 		const secondSeparator = result.stdout.indexOf("	", firstSeparator + 1);
 		const thirdSeparator = result.stdout.indexOf("	", secondSeparator + 1);
-		if (firstSeparator === -1 || secondSeparator === -1 || thirdSeparator === -1) return null;
-		const encodedShellTitle = result.stdout.slice(0, firstSeparator).trim();
+		const fourthSeparator = result.stdout.indexOf("	", thirdSeparator + 1);
+		if (firstSeparator === -1 || secondSeparator === -1 || thirdSeparator === -1 || fourthSeparator === -1) return null;
+		let fallbackShell = null;
 		let shellTitle = null;
 		try {
-			shellTitle = decodeMetadata(encodedShellTitle, z.string()) ?? null;
+			fallbackShell = decodeMetadata(result.stdout.slice(0, firstSeparator).trim(), z.string()) ?? null;
+			shellTitle = decodeMetadata(result.stdout.slice(firstSeparator + 1, secondSeparator).trim(), z.string()) ?? null;
 		} catch {}
-		const currentCommand = result.stdout.slice(firstSeparator + 1, secondSeparator).trim() || null;
-		const commandLine = result.stdout.slice(secondSeparator + 1, thirdSeparator).trim() || null;
+		const currentCommand = result.stdout.slice(secondSeparator + 1, thirdSeparator).trim() || null;
+		const commandLine = result.stdout.slice(thirdSeparator + 1, fourthSeparator).trim() || null;
 		return {
-			paneTitle: result.stdout.slice(thirdSeparator + 1).trim() || null,
+			paneTitle: result.stdout.slice(fourthSeparator + 1).trim() || null,
 			currentCommand,
 			commandLine,
-			shellTitle
+			shellTitle,
+			fallbackShell
 		};
 	}
 	async setSessionShellTitle(socketName, sessionName, title) {
@@ -4403,6 +4473,7 @@ var TreeportService = class {
 	closeOnSuccessTerminalIds = /* @__PURE__ */ new Set();
 	terminalIdsByWorktree = /* @__PURE__ */ new Map();
 	projectObservationTails = /* @__PURE__ */ new Map();
+	observedFolderIdentities = /* @__PURE__ */ new Map();
 	projectsSnapshotInFlight = null;
 	projectsSnapshotRevision = 0;
 	packages;
@@ -4600,9 +4671,11 @@ var TreeportService = class {
 		return this.deps.database.db.select({
 			id: projects.id,
 			name: projects.name,
+			kind: projects.kind,
+			rootPath: projects.repositoryPath,
 			repositoryPath: projects.repositoryPath,
 			lastOpenedAt: projects.lastOpenedAt
-		}).from(projects).where(eq(projects.isOpen, 0)).orderBy(desc(projects.lastOpenedAt), asc(projects.id));
+		}).from(projects).where(and(eq(projects.isOpen, 0), eq(projects.showInRecents, 1))).orderBy(desc(projects.lastOpenedAt), asc(projects.id));
 	}
 	async collectCurrentProjectsSnapshot() {
 		while (true) {
@@ -4615,7 +4688,8 @@ var TreeportService = class {
 		return (await Promise.all((await this.storedProjects(true)).map(async (storedProject) => {
 			let project = storedProject;
 			try {
-				await this.importWorktrees(project.id, project.repositoryPath, project.mainWorktreePath);
+				if (project.kind === "repository") await this.importWorktrees(project.id, project.repositoryPath, project.mainWorktreePath);
+				else project = await this.observeAvailableProject(project);
 				await this.ensureProjectTerminals(project.id);
 				project = await this.storedProject(project.id) ?? project;
 			} catch (error) {
@@ -4626,7 +4700,7 @@ var TreeportService = class {
 			}
 			if (await this.projectOpenState(project.id) !== true) return null;
 			await Promise.all(project.worktrees.map(async (worktree) => {
-				const [dirty, terminals] = await Promise.all([project.availability.state === "available" && !worktree.prunable ? this.deps.git.dirtyState(worktree.path).catch(() => null) : null, this.listWorktreeTerminals(worktree).catch((error) => {
+				const [dirty, terminals] = await Promise.all([project.kind === "repository" && project.availability.state === "available" && !worktree.prunable ? this.deps.git.dirtyState(worktree.path).catch(() => null) : null, this.listWorktreeTerminals(worktree).catch((error) => {
 					project.availability = {
 						state: "unavailable",
 						message: error instanceof Error ? error.message : String(error)
@@ -4667,6 +4741,8 @@ var TreeportService = class {
 				name: terminal.name,
 				tmuxSessionName: terminal.sessionName,
 				argv: terminal.argv,
+				shellCommand: terminal.shellCommand,
+				interactiveShell: terminal.interactiveShell,
 				status: terminal.status,
 				exitCode: terminal.exitCode,
 				createdAt: terminal.createdAt,
@@ -4730,7 +4806,7 @@ var TreeportService = class {
 		const direct = await this.storedProject(identifier);
 		if (direct) return direct;
 		const canonical = await fs.realpath(path.resolve(identifier)).catch(() => path.resolve(identifier));
-		const match = (await this.storedProjects()).find((project) => isPathWithin(canonical, project.repositoryPath) || project.worktrees.some((worktree) => isPathWithin(canonical, worktree.path)));
+		const match = (await this.storedProjects()).find((project) => isPathWithin(canonical, project.rootPath) || project.worktrees.some((worktree) => isPathWithin(canonical, worktree.path)));
 		if (!match) throw new DomainError("PROJECT_NOT_FOUND", `No registered project contains ${identifier}`, 404);
 		return match;
 	}
@@ -4798,7 +4874,7 @@ var TreeportService = class {
 				definitions: [],
 				diagnostics: []
 			}),
-			worktree && project ? loadZedTerminalPresetDefinitions({
+			worktree && project?.kind === "repository" ? loadZedTerminalPresetDefinitions({
 				projectId: project.id,
 				shell: this.deps.config.shell,
 				mainWorktreePath: project.mainWorktreePath,
@@ -4820,6 +4896,7 @@ var TreeportService = class {
 					name: preset.name,
 					executable: preset.executable,
 					args: [...preset.args],
+					shellCommand: null,
 					cwd: null,
 					env: {},
 					closeOnSuccess: preset.closeOnSuccess,
@@ -5069,18 +5146,21 @@ var TreeportService = class {
 			project: {
 				id: project.id,
 				name: project.name,
-				defaultBranch: project.defaultBranch
+				kind: project.kind,
+				defaultBranch: project.kind === "repository" ? project.defaultBranch : null
 			},
 			worktree: {
 				id: worktree.id,
 				name: worktree.name,
+				kind: worktree.kind,
 				branch: worktree.branch,
-				head: worktree.head
+				head: worktree.kind === "folder" ? null : worktree.head
 			}
 		};
 	}
 	async getWebPanelDiff(panelId) {
 		const context = await this.getWebPanelContext(panelId);
+		if (context.project.kind !== "repository" || !context.project.defaultBranch) throw new DomainError("GIT_NOT_AVAILABLE", "Git diff is not available for a folder project", 409);
 		const worktree = await this.getWorktree(context.panel.worktreeId);
 		return this.deps.git.worktreeDiff(worktree.path, context.project.defaultBranch);
 	}
@@ -5145,6 +5225,14 @@ var TreeportService = class {
 		if (!worktree) throw new DomainError("WORKTREE_NOT_FOUND", "Tree not found", 404);
 		return worktree;
 	}
+	async requestWorkspaceOpen(worktreeId, sourceTerminalId) {
+		const worktree = await this.getWorktree(worktreeId);
+		await this.requireOpenProject(worktree.projectId);
+		this.events.publish("workspace.open_requested", {
+			worktreeId,
+			sourceTerminalId
+		});
+	}
 	async getTerminal(terminalId) {
 		const matches = (await this.listProjects()).flatMap((project) => project.worktrees).flatMap((worktree) => worktree.terminals).filter((terminal) => terminal.id === terminalId);
 		if (matches.length > 1) throw new DomainError("TERMINAL_ID_CONFLICT", "Terminal ID is present in more than one tmux server", 500);
@@ -5178,7 +5266,7 @@ var TreeportService = class {
 		const direct = await this.storedProject(identifier);
 		if (direct) return await this.requireOpenProject(direct.id);
 		const canonical = await fs.realpath(path.resolve(identifier)).catch(() => path.resolve(identifier));
-		const match = (await this.storedProjects()).find((project) => isPathWithin(canonical, project.repositoryPath) || project.worktrees.some((worktree) => isPathWithin(canonical, worktree.path)));
+		const match = (await this.storedProjects()).find((project) => isPathWithin(canonical, project.rootPath) || project.worktrees.some((worktree) => isPathWithin(canonical, worktree.path)));
 		if (!match) throw new DomainError("PROJECT_NOT_FOUND", `No registered project contains ${identifier}`, 404);
 		await this.requireOpenProject(match.id);
 		return match;
@@ -5251,7 +5339,7 @@ var TreeportService = class {
 				path: breadcrumbPath
 			});
 		}
-		const repositoryPath = exact ? await this.deps.git.canonicalizeRepositoryPath(directoryPath).then((checkout) => this.deps.git.resolveMainCheckout(checkout)).then((mainCheckout) => fs.realpath(mainCheckout)).catch(() => null) : null;
+		const repositoryPath = exact ? await this.deps.git.findProjectRepositoryRoot(directoryPath).then((checkout) => checkout ? this.deps.git.resolveMainCheckout(checkout) : null).then((mainCheckout) => mainCheckout ? fs.realpath(mainCheckout) : null) : null;
 		return {
 			input: inputPath,
 			exact,
@@ -5264,6 +5352,18 @@ var TreeportService = class {
 				entries,
 				truncated
 			},
+			project: exact ? repositoryPath ? {
+				state: "valid",
+				kind: "repository",
+				path: repositoryPath
+			} : {
+				state: "valid",
+				kind: "folder",
+				path: directoryPath
+			} : {
+				state: "incomplete",
+				message: "Choose a matching folder to continue."
+			},
 			repository: repositoryPath ? {
 				state: "valid",
 				repositoryPath
@@ -5277,6 +5377,14 @@ var TreeportService = class {
 		};
 	}
 	async registerProject(inputPath, requestedName) {
+		const canonicalPath = await fs.realpath(path.resolve(inputPath)).catch((error) => {
+			throw new DomainError("FOLDER_UNREADABLE", error instanceof Error ? error.message : "Folder cannot be read", 400);
+		});
+		if (!(await fs.stat(canonicalPath, { bigint: true })).isDirectory()) throw new DomainError("FOLDER_NOT_DIRECTORY", `Path is not a folder: ${canonicalPath}`, 400);
+		const repositoryRoot = await this.deps.git.findProjectRepositoryRoot(canonicalPath);
+		return repositoryRoot ? this.registerRepositoryProject(repositoryRoot, requestedName) : this.registerFolderProject(canonicalPath, requestedName);
+	}
+	async registerRepositoryProject(inputPath, requestedName) {
 		const checkout = await this.deps.git.canonicalizeRepositoryPath(inputPath).catch((error) => {
 			throw new DomainError("NOT_A_GIT_REPOSITORY", error instanceof Error ? error.message : "Not a Git repository", 400);
 		});
@@ -5331,17 +5439,18 @@ var TreeportService = class {
 			if (verifiedIdentity !== repositoryIdentity || verifiedStat.dev.toString() !== repositoryDevice || verifiedStat.ino.toString() !== repositoryInode) throw new DomainError("PROJECT_PATH_CONFLICT", "The repository changed during registration", 409);
 			await this.deps.database.db.run(sql`
         INSERT INTO projects(
-          id,name,repository_path,main_worktree_path,default_branch,
+          id,name,project_kind,repository_path,main_worktree_path,default_branch,
           repository_identity,repository_device,repository_inode,name_is_custom,
-          is_open,last_opened_at,created_at,updated_at
+          is_open,show_in_recents,last_opened_at,created_at,updated_at
         ) VALUES(
-          ${projectId},${name},${repositoryPath},${mainPath},${defaultBranch},
+          ${projectId},${name},'repository',${repositoryPath},${mainPath},${defaultBranch},
           ${repositoryIdentity},${repositoryDevice},${repositoryInode},
-          ${nameIsCustom ? 1 : 0},1,${timestamp},
+          ${nameIsCustom ? 1 : 0},1,0,${timestamp},
           ${existing?.createdAt ?? timestamp},${timestamp}
         )
         ON CONFLICT(id) DO UPDATE SET
           name=excluded.name,
+          project_kind=excluded.project_kind,
           repository_path=excluded.repository_path,
           main_worktree_path=excluded.main_worktree_path,
           default_branch=excluded.default_branch,
@@ -5362,6 +5471,7 @@ var TreeportService = class {
 					const timestamp = now();
 					await this.deps.database.db.update(projects).set({
 						isOpen: 1,
+						showInRecents: 0,
 						lastOpenedAt: timestamp,
 						updatedAt: timestamp
 					}).where(eq(projects.id, projectId));
@@ -5382,9 +5492,123 @@ var TreeportService = class {
 		this.events.publish("project.created", { projectId });
 		return this.getProjectSnapshot(projectId);
 	}
+	async registerFolderProject(folderPath, requestedName) {
+		const folderStat = await fs.stat(folderPath, { bigint: true });
+		const device = folderStat.dev.toString();
+		const inode = folderStat.ino.toString();
+		const [pathMatchRow] = await this.deps.database.db.select({ id: projects.id }).from(projects).where(eq(projects.repositoryPath, folderPath)).limit(1);
+		const identityMatchId = [...this.observedFolderIdentities].find(([, identity]) => identity.device === device && identity.inode === inode)?.[0];
+		const [pathMatch, identityMatch] = await Promise.all([pathMatchRow ? this.storedProject(pathMatchRow.id) : null, identityMatchId ? this.storedProject(identityMatchId) : null]);
+		if (pathMatch?.kind === "repository") throw new DomainError("PROJECT_PATH_CONFLICT", "The selected folder is registered as a Git repository, but Git no longer recognizes it", 409);
+		const observedPathIdentity = pathMatch ? this.observedFolderIdentities.get(pathMatch.id) : null;
+		if (observedPathIdentity && (observedPathIdentity.device !== device || observedPathIdentity.inode !== inode)) throw new DomainError("PROJECT_PATH_CONFLICT", "The registered folder path now refers to a different folder", 409);
+		if (pathMatch && identityMatch && pathMatch.id !== identityMatch.id) throw new DomainError("PROJECT_PATH_CONFLICT", "The folder identity and registered path belong to different projects", 409);
+		const existing = identityMatch ?? pathMatch;
+		const projectId = existing?.id ?? id("proj");
+		const updateRegistration = async () => {
+			const timestamp = now();
+			const [metadata] = existing ? await this.deps.database.db.select({ nameIsCustom: projects.nameIsCustom }).from(projects).where(eq(projects.id, existing.id)).limit(1) : [];
+			const requested = requestedName?.trim() || null;
+			const nameIsCustom = requested ? true : Boolean(metadata?.nameIsCustom);
+			const name = requested || (existing && !nameIsCustom && existing.name === path.basename(existing.rootPath) ? path.basename(folderPath) : existing?.name) || path.basename(folderPath);
+			const [verifiedPath, verifiedStat] = await Promise.all([fs.realpath(folderPath), fs.stat(folderPath, { bigint: true })]);
+			if (verifiedPath !== folderPath || !verifiedStat.isDirectory() || verifiedStat.dev.toString() !== device || verifiedStat.ino.toString() !== inode) throw new DomainError("PROJECT_PATH_CONFLICT", "The folder changed during registration", 409);
+			const existingWorktreeRows = existing ? await this.deps.database.db.select().from(worktrees).where(eq(worktrees.projectId, projectId)) : [];
+			if (existingWorktreeRows.length > 1 || existingWorktreeRows.some((worktree) => worktree.kind !== "folder")) throw new DomainError("PROJECT_PATH_CONFLICT", "The folder registration contains incompatible Git worktrees", 409);
+			const existingWorktree = existingWorktreeRows[0];
+			const worktreeId = existingWorktree?.id ?? id("wt");
+			await this.deps.database.db.transaction(async (tx) => {
+				await tx.run(sql`
+          INSERT INTO projects(
+            id,name,project_kind,repository_path,main_worktree_path,default_branch,
+            repository_identity,repository_device,repository_inode,name_is_custom,
+            is_open,show_in_recents,last_opened_at,created_at,updated_at
+          ) VALUES(
+            ${projectId},${name},'folder',${folderPath},${folderPath},'',
+            NULL,${device},${inode},${nameIsCustom ? 1 : 0},1,0,${timestamp},
+            ${existing?.createdAt ?? timestamp},${timestamp}
+          )
+          ON CONFLICT(id) DO UPDATE SET
+            name=excluded.name,
+            project_kind='folder',
+            repository_path=excluded.repository_path,
+            main_worktree_path=excluded.main_worktree_path,
+            default_branch='',
+            repository_identity=NULL,
+            repository_device=excluded.repository_device,
+            repository_inode=excluded.repository_inode,
+            name_is_custom=excluded.name_is_custom,
+            is_open=1,
+            show_in_recents=0,
+            last_opened_at=excluded.last_opened_at,
+            updated_at=excluded.updated_at
+        `);
+				if (existingWorktree) await tx.run(sql`
+            UPDATE worktrees
+            SET path=${folderPath},git_worktree_key=NULL,head='',branch=NULL,
+                detached=0,locked=0,lock_reason=NULL,prunable=0,kind='folder',
+                managed_wrapper_path=NULL,pr_state='unknown',pr_number=NULL,
+                pr_url=NULL,pr_base_branch=NULL,pr_head_branch=NULL,
+                pr_merged_at=NULL,pr_refreshed_at=NULL,updated_at=${timestamp}
+            WHERE id=${worktreeId}
+          `);
+				else await tx.run(sql`
+            INSERT INTO worktrees(
+              id,project_id,path,git_worktree_key,head,branch,detached,locked,
+              lock_reason,prunable,kind,tmux_socket_name,created_at,updated_at
+            ) VALUES(
+              ${worktreeId},${projectId},${folderPath},NULL,'',NULL,0,0,NULL,0,
+              'folder',${generateTmuxSocketName()},${timestamp},${timestamp}
+            )
+          `);
+			});
+		};
+		const register = async () => {
+			if (this.projectLocks.has(projectId) || this.worktreeMutations.has(projectId)) throw new DomainError("PROJECT_BUSY", "Project is already being modified", 409);
+			this.projectLocks.add(projectId);
+			try {
+				await updateRegistration();
+			} finally {
+				this.projectLocks.delete(projectId);
+			}
+		};
+		if (existing) await this.serializeProjectObservation(projectId, register);
+		else await register();
+		this.observedFolderIdentities.set(projectId, {
+			device,
+			inode
+		});
+		await this.packages.registerProject(await this.getProject(projectId));
+		await this.ensureProjectTerminals(projectId).catch(() => void 0);
+		this.invalidateProjectsSnapshot();
+		this.events.publish(existing ? "project.updated" : "project.created", { projectId });
+		return this.getProjectSnapshot(projectId);
+	}
 	async observeAvailableProject(project, allowClosed = false) {
 		try {
-			await this.importWorktrees(project.id, project.repositoryPath, project.mainWorktreePath, true, allowClosed);
+			if (project.kind === "repository") await this.importWorktrees(project.id, project.repositoryPath, project.mainWorktreePath, true, allowClosed);
+			else await this.serializeProjectObservation(project.id, async () => {
+				if (!allowClosed && await this.projectOpenState(project.id) !== true || this.worktreeMutations.has(project.id)) return;
+				const [metadata] = await this.deps.database.db.select({
+					device: projects.repositoryDevice,
+					inode: projects.repositoryInode
+				}).from(projects).where(eq(projects.id, project.id)).limit(1);
+				const [canonicalPath, folderStat] = await Promise.all([fs.realpath(project.rootPath), fs.stat(project.rootPath, { bigint: true })]);
+				if (!metadata || canonicalPath !== project.rootPath || !folderStat.isDirectory()) throw new Error("The registered folder path is not an available directory");
+				const device = folderStat.dev.toString();
+				const inode = folderStat.ino.toString();
+				const observedIdentity = this.observedFolderIdentities.get(project.id);
+				if (observedIdentity && (observedIdentity.device !== device || observedIdentity.inode !== inode)) throw new Error("The registered folder path changed during this daemon session");
+				if (project.worktrees.filter((worktree) => worktree.kind === "folder" && worktree.path === project.rootPath).length !== 1 || project.worktrees.length !== 1) throw new Error("The registered folder does not have one folder workspace");
+				if (metadata.device !== device || metadata.inode !== inode) await this.deps.database.db.update(projects).set({
+					repositoryDevice: device,
+					repositoryInode: inode
+				}).where(eq(projects.id, project.id));
+				this.observedFolderIdentities.set(project.id, {
+					device,
+					inode
+				});
+			});
 		} catch (error) {
 			throw new DomainError("PROJECT_UNAVAILABLE", error instanceof Error ? error.message : String(error), 503);
 		}
@@ -5397,12 +5621,14 @@ var TreeportService = class {
 		try {
 			const project = await this.observeAvailableProject(await this.getProject(projectId));
 			await this.ensureProjectTerminals(projectId);
-			const defaultBranch = await this.deps.git.defaultBranch(project.repositoryPath);
-			await this.deps.database.db.run(sql`
-        UPDATE projects
-        SET default_branch = ${defaultBranch}, updated_at = ${now()}
-        WHERE id = ${projectId}
-      `);
+			if (project.kind === "repository") {
+				const defaultBranch = await this.deps.git.defaultBranch(project.repositoryPath);
+				await this.deps.database.db.run(sql`
+          UPDATE projects
+          SET default_branch = ${defaultBranch}, updated_at = ${now()}
+          WHERE id = ${projectId}
+        `);
+			}
 			await this.reconcile();
 			await this.packages.registerProject(await this.getProject(projectId));
 			this.invalidateProjectsSnapshot();
@@ -5421,6 +5647,7 @@ var TreeportService = class {
 				const timestamp = now();
 				await this.deps.database.db.update(projects).set({
 					isOpen: 1,
+					showInRecents: 0,
 					lastOpenedAt: timestamp,
 					updatedAt: timestamp
 				}).where(eq(projects.id, projectId));
@@ -5462,6 +5689,7 @@ var TreeportService = class {
 				try {
 					await this.deps.database.db.update(projects).set({
 						isOpen: 0,
+						showInRecents: 1,
 						updatedAt: now()
 					}).where(eq(projects.id, projectId));
 				} catch (error) {
@@ -5479,6 +5707,17 @@ var TreeportService = class {
 			}
 		});
 	}
+	async dismissRecentProject(projectId) {
+		await this.serializeProjectObservation(projectId, async () => {
+			await this.getProject(projectId);
+			if (await this.projectOpenState(projectId) !== false) throw new DomainError("PROJECT_NOT_RECENT", "Project is open and cannot be removed from Recent projects", 409);
+			await this.deps.database.db.update(projects).set({
+				showInRecents: 0,
+				updatedAt: now()
+			}).where(and(eq(projects.id, projectId), eq(projects.isOpen, 0)));
+			this.events.publish("project.updated", { projectId });
+		});
+	}
 	async serializeProjectObservation(projectId, operation) {
 		const observation = (this.projectObservationTails.get(projectId) ?? Promise.resolve()).then(operation);
 		const tail = observation.then(() => void 0, () => void 0);
@@ -5663,7 +5902,7 @@ var TreeportService = class {
 		return (await this.deps.database.db.select().from(operations).where(and(or(eq(operations.status, "pending"), eq(operations.status, "running")), ...filters.projectId ? [eq(operations.projectId, filters.projectId)] : [], ...filters.kind ? [eq(operations.kind, filters.kind)] : [])).orderBy(asc(operations.createdAt), asc(operations.id))).map(mapOperation);
 	}
 	async beginCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId) {
-		await this.requireOpenProject(projectId);
+		if ((await this.requireOpenProject(projectId)).kind === "folder") throw new DomainError("PROJECT_HAS_NO_GIT_REPOSITORY", "Linked worktrees require a Git repository project", 409);
 		let name;
 		try {
 			name = normalizeWorktreeName(inputName);
@@ -5734,7 +5973,7 @@ var TreeportService = class {
 		}
 	}
 	async createWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId) {
-		await this.requireOpenProject(projectId);
+		if ((await this.requireOpenProject(projectId)).kind === "folder") throw new DomainError("PROJECT_HAS_NO_GIT_REPOSITORY", "Linked worktrees require a Git repository project", 409);
 		if (this.projectLocks.has(projectId) && !this.worktreeMutations.has(projectId)) throw new DomainError("PROJECT_BUSY", "Project is already being modified", 409);
 		return this.worktreeMutations.enqueue(projectId, () => this.executeCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId));
 	}
@@ -5749,6 +5988,7 @@ var TreeportService = class {
 		let wrapperCreated = false;
 		try {
 			project = await this.observeAvailableProject(await this.requireOpenProject(projectId));
+			if (project.kind === "folder") throw new DomainError("PROJECT_HAS_NO_GIT_REPOSITORY", "Linked worktrees require a Git repository project", 409);
 			let name;
 			try {
 				name = normalizeWorktreeName(inputName);
@@ -5902,7 +6142,13 @@ var TreeportService = class {
 		const project = await this.requireOpenProject(worktree.projectId);
 		const terminalId = id("term");
 		const sessionName = generateTmuxSessionName();
-		const commandArgv = argv ? [...argv] : [this.deps.config.shell, "-l"];
+		const shellCommand = options?.shellCommand ?? null;
+		const interactiveShell = !argv && shellCommand === null;
+		const commandArgv = argv ? [...argv] : shellCommand ? [
+			this.deps.config.shell,
+			"-lc",
+			shellCommand
+		] : [this.deps.config.shell, "-l"];
 		const timestamp = now();
 		const session = {
 			socketName: worktree.tmuxSocketName,
@@ -5913,6 +6159,8 @@ var TreeportService = class {
 			createdAt: timestamp,
 			cwd: options?.cwd ?? worktree.path,
 			argv: commandArgv,
+			shellCommand,
+			interactiveShell,
 			env: {
 				...options?.env ?? {},
 				TREEPORT_API_URL: this.deps.config.apiUrl,
@@ -5924,7 +6172,7 @@ var TreeportService = class {
 				TREEPORT_TERMINAL_ID: terminalId
 			}
 		};
-		if (options?.returnToShell && argv) session.fallbackArgv = [this.deps.config.shell, "-l"];
+		if (options?.returnToShell && !interactiveShell) session.fallbackArgv = [this.deps.config.shell, "-l"];
 		if (options?.closeOnSuccess) session.closeOnSuccess = true;
 		if (options?.initialSize) session.initialSize = options.initialSize;
 		if (options?.setup?.tasks.length) session.setupTasks = options.setup.tasks;
@@ -5940,6 +6188,8 @@ var TreeportService = class {
 			name,
 			tmuxSessionName: sessionName,
 			argv: commandArgv,
+			shellCommand,
+			interactiveShell,
 			status: "running",
 			exitCode: null,
 			createdAt: timestamp,
@@ -5980,7 +6230,7 @@ var TreeportService = class {
 		}
 	}
 	async refreshTerminalStatus(terminalId, observeGit = true) {
-		const terminal = observeGit ? await this.getTerminal(terminalId) : await this.getTerminalFromBindings(terminalId);
+		const terminal = observeGit ? await this.getTerminal(terminalId) : this.terminalStates.get(terminalId) ?? await this.getTerminalFromBindings(terminalId);
 		const worktree = await this.getWorktree(terminal.worktreeId);
 		const state = await this.deps.tmux.sessionState(worktree.tmuxSocketName, terminal.tmuxSessionName);
 		await this.requireOpenProject(worktree.projectId);
@@ -6098,6 +6348,7 @@ var TreeportService = class {
 		const worktree = await this.requireAvailableWorktree(worktreeId, true);
 		worktree.terminals = await this.listWorktreeTerminals(worktree);
 		const project = await this.getProject(worktree.projectId);
+		if (project.kind === "folder") throw new DomainError("FOLDER_WORKSPACE_NOT_REMOVABLE", "Remove the folder project instead of its folder workspace", 409);
 		const live = (await this.deps.git.listWorktrees(project.repositoryPath)).find((item) => item.path === worktree.path);
 		if (!live) throw new DomainError("WORKTREE_NOT_FOUND", "Git no longer reports this worktree", 404);
 		const head = live.head ?? worktree.head;
@@ -6433,6 +6684,7 @@ var TreeportService = class {
 			const terminalIdsByWorktree = /* @__PURE__ */ new Map();
 			for (const worktree of project.worktrees) terminalIdsByWorktree.set(worktree.id, await this.deps.tmux.killServer(worktree.tmuxSocketName));
 			await this.deps.database.db.run(sql`DELETE FROM projects WHERE id=${projectId}`);
+			this.observedFolderIdentities.delete(projectId);
 			this.packages.forgetProject(projectId);
 			for (const worktree of project.worktrees) this.clearWorktreeTerminalState(worktree.id, terminalIdsByWorktree.get(worktree.id));
 			this.invalidateProjectsSnapshot();
@@ -6459,7 +6711,7 @@ var TreeportService = class {
 	async reconcile() {
 		const availableProjects = /* @__PURE__ */ new Set();
 		for (const project of await this.storedProjects(true)) try {
-			await this.importWorktrees(project.id, project.repositoryPath, project.mainWorktreePath);
+			await this.observeAvailableProject(project);
 			availableProjects.add(project.id);
 		} catch {}
 		for (const project of await this.storedProjects(true)) {
@@ -6827,6 +7079,7 @@ async function terminateProcess(child, terminationStarted) {
 var TmuxProgressObserver = class {
 	options;
 	spawnProcess;
+	closed;
 	lifecycleFiber;
 	process = null;
 	metadataParser = null;
@@ -6841,6 +7094,7 @@ var TmuxProgressObserver = class {
 		this.options = options;
 		this.spawnProcess = spawnProcess;
 		this.lifecycleFiber = Effect.runFork(Effect.scoped(this.lifecycle()).pipe(Effect.catchAll(() => Effect.sync(() => this.notifyExit()))));
+		this.closed = Effect.runPromise(Fiber.await(this.lifecycleFiber)).then(() => void 0);
 	}
 	dispose() {
 		if (this.disposed) return;
@@ -6997,22 +7251,6 @@ const PROGRAM_COMMANDS = /* @__PURE__ */ new Map([
 	["claude", "claude"],
 	["codex", "codex"]
 ]);
-const SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"ash",
-	"bash",
-	"csh",
-	"dash",
-	"elvish",
-	"fish",
-	"ksh",
-	"mksh",
-	"nu",
-	"pwsh",
-	"sh",
-	"tcsh",
-	"xonsh",
-	"zsh"
-]);
 var TerminalMetadataRuntimeError = class {
 	phase;
 	terminalId;
@@ -7039,6 +7277,7 @@ var TerminalMetadataManager = class {
 	bellMutations = new KeyedTaskQueue();
 	bellDeletionVersions = /* @__PURE__ */ new Map();
 	persistedBells = /* @__PURE__ */ new Map();
+	observerShutdowns = /* @__PURE__ */ new Set();
 	bellStateStore;
 	initializePromise = null;
 	unsubscribeEvents = null;
@@ -7104,8 +7343,10 @@ var TerminalMetadataManager = class {
 			entry = void 0;
 		}
 		if (!entry) {
-			const launchCommand = path.basename(terminal.argv?.[0] ?? "").replace(/^-/, "");
-			const launchProgram = PROGRAM_COMMANDS.get(launchCommand) ?? null;
+			const launchCommand = path.basename(terminal.argv[0] ?? "").replace(/^-/, "");
+			const launchProgram = !terminal.interactiveShell && terminal.shellCommand === null ? PROGRAM_COMMANDS.get(launchCommand) ?? null : null;
+			const interactiveShellCommand = terminal.interactiveShell ? launchCommand : null;
+			const launchCommandLine = terminal.interactiveShell ? null : (terminal.shellCommand?.replace(/\p{Cc}/gu, "") ?? formatCommandLine(terminal.argv.map((value) => value.replace(/\p{Cc}/gu, "")))).trim().slice(0, 256) || null;
 			this.bellDeletionVersions.set(terminal.id, (this.bellDeletionVersions.get(terminal.id) ?? 0) + 1);
 			const persistedBell = this.persistedBells.get(terminal.id);
 			const bell = persistedBell?.worktreeId === terminal.worktreeId ? {
@@ -7130,7 +7371,8 @@ var TerminalMetadataManager = class {
 				paneTitle: null,
 				currentCommand: null,
 				commandLine: null,
-				shellCommand: SHELL_COMMANDS.has(launchCommand) ? launchCommand : null,
+				launchCommandLine,
+				interactiveShellCommand,
 				launchProgram,
 				shellTitle: null,
 				persistedShellTitle: null,
@@ -7234,8 +7476,9 @@ var TerminalMetadataManager = class {
 		this.listeners.clear();
 		this.historyListeners.clear();
 	}
-	drain() {
-		return this.bellMutations.drain();
+	async drain() {
+		await this.bellMutations.drain();
+		await Promise.allSettled([...this.observerShutdowns]);
 	}
 	handleProductEvent(event) {
 		if (event.type === "terminal.removed") {
@@ -7403,7 +7646,7 @@ var TerminalMetadataManager = class {
 						this.update(entry, { progress: null });
 					}
 				});
-				if (exited || this.entries.get(entry.terminalId) !== entry || entry.runtimeGeneration !== runtimeGeneration || entry.observerVersion !== version) observer.dispose();
+				if (exited || this.entries.get(entry.terminalId) !== entry || entry.runtimeGeneration !== runtimeGeneration || entry.observerVersion !== version) this.disposeObserver(observer);
 				else entry.observer = observer;
 			},
 			catch: (cause) => new TerminalMetadataRuntimeError("create_observer", entry.terminalId, cause)
@@ -7432,17 +7675,31 @@ var TerminalMetadataManager = class {
 		}
 		this.update(entry, { progress: null });
 	}
+	disposeObserver(observer) {
+		observer.dispose();
+		if (!observer.closed) return;
+		const shutdown = observer.closed;
+		this.observerShutdowns.add(shutdown);
+		shutdown.then(() => this.observerShutdowns.delete(shutdown), () => this.observerShutdowns.delete(shutdown));
+	}
 	releaseRuntimeResources(entry) {
 		entry.observerVersion += 1;
-		entry.observer?.dispose();
-		entry.observer = null;
+		if (entry.observer) {
+			this.disposeObserver(entry.observer);
+			entry.observer = null;
+		}
 		this.clearProgressRuntime(entry);
 		entry.shellTitleWriting = false;
 	}
 	reconcileTitleState(entry, state) {
 		const paneTitle = state.paneTitle?.trim().slice(0, 256) || null;
 		const currentCommand = state.currentCommand?.trim().slice(0, 256) || null;
-		const commandLine = state.commandLine?.trim().slice(0, 256) || null;
+		const fallbackShellCommand = path.basename(state.fallbackShell ?? "").replace(/^-/, "").replace(/\p{Cc}/gu, "").trim().slice(0, 256);
+		if (fallbackShellCommand) {
+			entry.launchCommandLine = null;
+			entry.interactiveShellCommand = fallbackShellCommand;
+		}
+		const commandLine = state.commandLine?.trim().slice(0, 256) || entry.launchCommandLine;
 		const previousCommand = entry.currentCommand;
 		const previousCommandLine = entry.commandLine;
 		const paneTitleChanged = paneTitle !== entry.paneTitle;
@@ -7462,12 +7719,8 @@ var TerminalMetadataManager = class {
 		const commandToken = commandLine?.match(/^(?:exec\s+|command\s+)?(?:"([^"]+)"|'([^']+)'|(\S+))/);
 		const commandExecutable = commandToken ? commandToken[1] || commandToken[2] || commandToken[3] || null : null;
 		const observedProgram = PROGRAM_COMMANDS.get(path.basename(commandExecutable ?? "").replace(/^-/, "")) ?? PROGRAM_COMMANDS.get(path.basename(currentCommand ?? "").replace(/^-/, "")) ?? null;
-		this.update(entry, { program: observedProgram ?? (!entry.shellCommand ? entry.launchProgram : null) });
-		if (!entry.shellCommand) {
-			this.update(entry, { title: paneTitle ?? commandLine ?? currentCommand });
-			return;
-		}
-		if (currentCommand === entry.shellCommand) {
+		this.update(entry, { program: observedProgram ?? (!entry.interactiveShellCommand ? entry.launchProgram : null) });
+		if (entry.interactiveShellCommand && currentCommand === entry.interactiveShellCommand) {
 			const applicationTitleWasActive = entry.applicationTitleActive;
 			const freshShellTitle = observedTitlePending || previousCommand !== null && paneTitleChanged;
 			entry.applicationTitleActive = false;
@@ -7481,11 +7734,15 @@ var TerminalMetadataManager = class {
 		}
 		if (commandLine) {
 			if (observedTitlePending) entry.applicationTitleActive = paneTitle !== null && paneTitle !== commandLine;
-			else if (commandLineChanged) entry.applicationTitleActive = previousCommand === null && paneTitle !== null && paneTitle !== commandLine && paneTitle !== entry.shellTitle;
+			else if (commandLineChanged) entry.applicationTitleActive = entry.interactiveShellCommand !== null && previousCommand === null && paneTitle !== null && paneTitle !== commandLine && paneTitle !== entry.shellTitle;
 			else if (paneTitleChanged && paneTitle !== commandLine) entry.applicationTitleActive = true;
 			this.update(entry, { title: entry.applicationTitleActive ? paneTitle ?? entry.title ?? commandLine : commandLine });
 			return;
 		}
+		if (!entry.interactiveShellCommand) {
+			this.update(entry, { title: paneTitle ?? currentCommand });
+			return;
+		}
 		if (observedTitlePending) {
 			entry.applicationTitleActive = true;
 			this.update(entry, { title: entry.title ?? paneTitle ?? currentCommand });
@@ -7514,7 +7771,7 @@ var TerminalMetadataManager = class {
 	}
 	updateForegroundProcess(entry, currentCommand) {
 		const command = currentCommand?.trim().slice(0, 256) || null;
-		this.update(entry, { hasForegroundProcess: entry.status !== "running" ? false : command === null ? null : command !== entry.shellCommand });
+		this.update(entry, { hasForegroundProcess: entry.status !== "running" ? false : command === null ? null : command !== entry.interactiveShellCommand });
 	}
 	persistShellTitle(entry, runtimeGeneration) {
 		return Effect.gen(this, function* () {
@@ -7638,7 +7895,7 @@ function queryInput(schema) {
 		if (!result.success) throw new DomainError("VALIDATION_ERROR", "Request validation failed", 400, z.flattenError(result.error));
 	});
 }
-function createApp({ service, config, tmux, terminalMetadata, webDist }) {
+function createApp({ service, config, tmux, applicationUpdate, terminalMetadata, webDist }) {
 	const app = new Hono();
 	app.use("/api/*", requestId({
 		limitLength: 128,
@@ -7688,7 +7945,13 @@ function createApp({ service, config, tmux, terminalMetadata, webDist }) {
 		installationMethod: config.installationMethod ?? "development",
 		daemonLifecycle: config.daemonLifecycle,
 		url: config.apiUrl
-	})).get("/api/terminal-presets", async (context) => context.json({ presets: await service.listTerminalPresets() })).get("/api/terminal-preset-definitions", queryInput(terminalPresetDefinitionsQuerySchema), async (context) => context.json(await service.listTerminalPresetDefinitions(context.req.valid("query")))).post("/api/terminal-presets", jsonInput(createTerminalPresetSchema), async (context) => {
+	})).get("/api/update", async (context) => {
+		context.header("Cache-Control", "no-store");
+		return context.json(await applicationUpdate.status());
+	}).post("/api/update", async (context) => {
+		context.header("Cache-Control", "no-store");
+		return context.json(await applicationUpdate.start(), 202);
+	}).get("/api/terminal-presets", async (context) => context.json({ presets: await service.listTerminalPresets() })).get("/api/terminal-preset-definitions", queryInput(terminalPresetDefinitionsQuerySchema), async (context) => context.json(await service.listTerminalPresetDefinitions(context.req.valid("query")))).post("/api/terminal-presets", jsonInput(createTerminalPresetSchema), async (context) => {
 		const body = context.req.valid("json");
 		return context.json({ preset: await service.createTerminalPreset(body) }, 201);
 	}).patch("/api/terminal-presets/:presetId", jsonInput(updateTerminalPresetSchema), async (context) => {
@@ -7720,6 +7983,9 @@ function createApp({ service, config, tmux, terminalMetadata, webDist }) {
 	}).post("/api/projects/:projectId/open", async (context) => context.json({ project: await service.openProject(context.req.param("projectId")) })).post("/api/projects/:projectId/close", async (context) => {
 		await service.closeProject(context.req.param("projectId"));
 		return context.json({ ok: true });
+	}).delete("/api/projects/:projectId/recent", async (context) => {
+		await service.dismissRecentProject(context.req.param("projectId"));
+		return context.json({ ok: true });
 	}).get("/api/projects/:projectId", async (context) => context.json({ project: await service.getProjectSnapshot(context.req.param("projectId")) })).patch("/api/projects/:projectId", jsonInput(updateProjectSchema), async (context) => {
 		const body = context.req.valid("json");
 		const projectId = context.req.param("projectId");
@@ -7746,6 +8012,9 @@ function createApp({ service, config, tmux, terminalMetadata, webDist }) {
 		const worktreeId = context.req.param("worktreeId");
 		await service.refreshPr(worktreeId, false);
 		return context.json({ worktree: await service.getWorktreeSnapshot(worktreeId) });
+	}).post("/api/worktrees/:worktreeId/open", jsonInput(requestWorkspaceOpenSchema), async (context) => {
+		await service.requestWorkspaceOpen(context.req.param("worktreeId"), context.req.valid("json").sourceTerminalId);
+		return context.json({ ok: true });
 	}).get("/api/worktrees/:worktreeId/web-panel-definitions", async (context) => context.json({ definitions: await service.listWebPanelDefinitions(context.req.param("worktreeId")) })).post("/api/worktrees/:worktreeId/panels", jsonInput(createWebPanelSchema), async (context) => {
 		const body = context.req.valid("json");
 		return context.json({ panel: await service.createWebPanel(context.req.param("worktreeId"), body.definitionId, {
@@ -7827,6 +8096,7 @@ function createApp({ service, config, tmux, terminalMetadata, webDist }) {
 		if (body.initialSize) options.initialSize = body.initialSize;
 		if (body.cwd) options.cwd = body.cwd;
 		if (body.env) options.env = body.env;
+		if (body.shellCommand) options.shellCommand = body.shellCommand;
 		const terminal = await service.createTerminal(context.req.param("worktreeId"), body.name, body.argv, Object.keys(options).length > 0 ? options : void 0);
 		return context.json({ terminal }, 201);
 	}).get("/api/worktrees/:worktreeId/remove-preview", async (context) => context.json({ preview: await service.removePreview(context.req.param("worktreeId")) })).post("/api/worktrees/:worktreeId/remove", jsonInput(removeWorktreeSchema), async (context) => {
@@ -7947,6 +8217,247 @@ function createApp({ service, config, tmux, terminalMetadata, webDist }) {
 	return routes;
 }
 //#endregion
+//#region src/server/application-update.ts
+const POLL_INTERVAL_MS = 10 * 6e4;
+const POLL_JITTER_MS = 6e4;
+const updateResultSchema = z.looseObject({
+	schemaVersion: z.literal(1),
+	operationId: z.string().uuid(),
+	status: z.enum(["current", "updated"]),
+	phase: z.literal("complete"),
+	fromVersion: z.string(),
+	toVersion: z.string()
+});
+const updateErrorSchema = z.looseObject({ error: z.looseObject({
+	code: z.string(),
+	message: z.string(),
+	details: z.looseObject({
+		operationId: z.string().optional(),
+		recovery: z.string().optional()
+	}).optional()
+}) });
+async function readValidatedJson(filePath, schema) {
+	return fs.readFile(filePath, "utf8").then((value) => schema.safeParse(JSON.parse(value))).then((result) => result.success ? result.data : null).catch(() => null);
+}
+async function fileExists(filePath) {
+	return fs.access(filePath).then(() => true).catch(() => false);
+}
+function createApplicationUpdateManager(config, dependencies = {}) {
+	const environment = dependencies.environment ?? process.env;
+	const resolveRelease = dependencies.resolveRelease ?? resolveLatestTreeportRelease;
+	const inspectInstallation = dependencies.inspectInstallation ?? inspectLocalUpdateInstallation;
+	const readProgress = dependencies.readProgress ?? readLocalUpdateProgress;
+	const readServiceStatus = dependencies.readServiceStatus ?? serviceStatus;
+	const spawnProcess = dependencies.spawnProcess ?? spawn;
+	const random = dependencies.random ?? Math.random;
+	const pollIntervalMs = dependencies.pollIntervalMs ?? POLL_INTERVAL_MS;
+	const pollJitterMs = dependencies.pollJitterMs ?? POLL_JITTER_MS;
+	const updateDirectory = path.join(config.dataDir, "updates");
+	const resultPath = path.join(updateDirectory, "web-update-result.json");
+	const errorPath = path.join(updateDirectory, "web-update-error.json");
+	const currentVersion = config.appVersion ?? "development";
+	const staticBlockedReason = config.installationMethod !== "npm" ? "This Treeport installation cannot update itself. Update it with its installation method." : config.daemonLifecycle === "external" ? "This Treeport daemon is managed by another process. Update it on the host." : !isCanonicalTreeportVersion(currentVersion) ? "Development and prerelease Treeport versions do not update from the stable npm channel." : null;
+	let latestVersion = null;
+	let checkedAt = null;
+	let capabilityChecked = staticBlockedReason !== null;
+	let canUpdate = false;
+	let blockedReason = staticBlockedReason;
+	let installation = null;
+	let checking = false;
+	let checkPromise = null;
+	let pollingStarted = false;
+	let disposed = false;
+	let pollTimer = null;
+	let launching = false;
+	let launchError = null;
+	const refreshCapability = async () => {
+		if (staticBlockedReason) {
+			capabilityChecked = true;
+			canUpdate = false;
+			blockedReason = staticBlockedReason;
+			installation = null;
+			return;
+		}
+		const [installationResult, serviceResult] = await Promise.all([inspectInstallation(environment).then((value) => ({
+			value,
+			error: null
+		}), (cause) => ({
+			value: null,
+			error: cause
+		})), config.daemonLifecycle === "service" ? readServiceStatus().then((value) => ({
+			value,
+			error: null
+		}), (cause) => ({
+			value: null,
+			error: cause
+		})) : Promise.resolve({
+			value: null,
+			error: null
+		})]);
+		capabilityChecked = true;
+		installation = installationResult.value;
+		if (!installation) {
+			canUpdate = false;
+			blockedReason = installationResult.error instanceof Error ? installationResult.error.message : "Treeport could not verify this npm installation.";
+			return;
+		}
+		if (serviceResult.error) {
+			canUpdate = false;
+			blockedReason = "Treeport could not verify the service update lifecycle.";
+			return;
+		}
+		if (serviceResult.value?.mode === "headless" && (serviceResult.value.active || serviceResult.value.daemon?.running)) {
+			canUpdate = false;
+			blockedReason = "Stop the advanced headless service with its administrator action before you update Treeport.";
+			return;
+		}
+		canUpdate = true;
+		blockedReason = null;
+	};
+	const status = async () => {
+		const [progress, result, updateError, resultFileExists, errorFileExists] = await Promise.all([
+			readProgress(config.dataDir),
+			readValidatedJson(resultPath, updateResultSchema),
+			readValidatedJson(errorPath, updateErrorSchema),
+			fileExists(resultPath),
+			fileExists(errorPath)
+		]);
+		if (progress.active) launching = false;
+		const resultMatchesOperation = !result || !progress.operationId || result.operationId === progress.operationId;
+		const errorOperationId = updateError?.error.details?.operationId ?? null;
+		const errorMatchesOperation = !updateError || !errorOperationId || !progress.operationId || errorOperationId === progress.operationId;
+		const available = Boolean(latestVersion && isCanonicalTreeportVersion(currentVersion) && compareTreeportVersions(latestVersion, currentVersion) > 0);
+		const recoveryError = progress.recoveryAction;
+		const cliError = errorMatchesOperation ? updateError?.error : null;
+		const interrupted = Boolean(!progress.active && progress.phase && progress.phase !== "complete" && (resultFileExists || errorFileExists) && !result && !updateError);
+		const error = launchError ?? (cliError ? [cliError.message, cliError.details?.recovery].filter((value, index, values) => Boolean(value && values.indexOf(value) === index)).join(" ") : recoveryError) ?? (interrupted ? "The update process stopped before it returned a result. Retry the update or run `treeport update` on the host." : null);
+		const inactiveFailedPhase = interrupted || progress.phase === "rollback" || progress.phase === "recovery_required";
+		const phase = progress.active ? progress.phase ?? "starting" : launching ? "starting" : launchError || cliError || inactiveFailedPhase ? progress.phase === "recovery_required" ? "recovery_required" : "failed" : result && resultMatchesOperation ? "complete" : progress.phase === "complete" ? "complete" : checking ? "checking" : "idle";
+		return {
+			currentVersion,
+			latestVersion,
+			updateAvailable: available,
+			checkedAt,
+			canUpdate: canUpdate && !progress.active && !launching,
+			blockedReason: capabilityChecked ? blockedReason : "Treeport is checking whether this installation can update itself.",
+			phase,
+			operationId: progress.operationId ?? result?.operationId ?? null,
+			targetVersion: progress.toVersion ?? result?.toVersion ?? latestVersion ?? null,
+			error: error || null
+		};
+	};
+	const check = async () => {
+		if (staticBlockedReason || disposed) return;
+		if ((await readProgress(config.dataDir)).active) return;
+		if (checkPromise) return checkPromise;
+		checking = true;
+		checkPromise = Promise.all([resolveRelease(environment).then((value) => ({
+			value,
+			error: null
+		}), (cause) => ({
+			value: null,
+			error: cause
+		})), refreshCapability()]).then(([releaseResult]) => {
+			if (releaseResult.value) {
+				latestVersion = releaseResult.value.version;
+				checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+			} else console.warn("[Treeport] Application update check failed:", releaseResult.error instanceof Error ? releaseResult.error.message : String(releaseResult.error));
+		});
+		await checkPromise.finally(() => {
+			checking = false;
+			checkPromise = null;
+		});
+	};
+	const scheduleNextCheck = () => {
+		if (disposed || !pollingStarted || staticBlockedReason) return;
+		const delay = pollIntervalMs + Math.floor(random() * pollJitterMs);
+		pollTimer = setTimeout(() => {
+			pollTimer = null;
+			check().finally(scheduleNextCheck);
+		}, delay);
+		pollTimer.unref?.();
+	};
+	return {
+		status,
+		check,
+		beginPolling() {
+			if (pollingStarted || disposed || staticBlockedReason) return;
+			pollingStarted = true;
+			check().finally(scheduleNextCheck);
+		},
+		async start() {
+			const currentStatus = await status();
+			if (!currentStatus.updateAvailable) throw new DomainError("APPLICATION_UPDATE_NOT_AVAILABLE", "A newer stable Treeport release is not available.", 409);
+			if (launching || [
+				"starting",
+				"inspect",
+				"resolve",
+				"stage",
+				"verify",
+				"stop",
+				"activate",
+				"restart",
+				"health_check",
+				"rollback"
+			].includes(currentStatus.phase)) throw new DomainError("APPLICATION_UPDATE_IN_PROGRESS", "Another Treeport update is already running.", 409);
+			launching = true;
+			launchError = null;
+			const launchResult = await (async () => {
+				await refreshCapability();
+				if (!canUpdate || !installation) throw new DomainError("APPLICATION_UPDATE_BLOCKED", blockedReason ?? "This Treeport installation cannot update itself.", 409);
+				const entrypoint = installation.entrypoint;
+				await fs.mkdir(updateDirectory, {
+					recursive: true,
+					mode: 448
+				});
+				await Promise.all([fs.rm(resultPath, { force: true }), fs.rm(errorPath, { force: true })]);
+				const [resultFile, errorFile] = await Promise.all([fs.open(resultPath, "wx", 384), fs.open(errorPath, "wx", 384)]);
+				const spawnResult = await new Promise((resolve, reject) => {
+					const child = spawnProcess(entrypoint, ["update", "--json"], {
+						env: environment,
+						detached: true,
+						shell: false,
+						stdio: [
+							"ignore",
+							resultFile.fd,
+							errorFile.fd
+						]
+					});
+					child.once("spawn", () => resolve(child));
+					child.once("error", reject);
+					child.once("exit", () => {
+						launching = false;
+					});
+				}).then((child) => ({
+					child,
+					error: null
+				}), (cause) => ({
+					child: null,
+					error: cause
+				}));
+				await Promise.all([resultFile.close(), errorFile.close()]);
+				if (!spawnResult.child) throw spawnResult.error instanceof Error ? spawnResult.error : /* @__PURE__ */ new Error("Treeport could not start the update process.");
+				spawnResult.child.unref();
+			})().then(() => ({ error: null }), (cause) => ({ error: cause }));
+			if (launchResult.error) {
+				launching = false;
+				if (launchResult.error instanceof DomainError) throw launchResult.error;
+				launchError = launchResult.error instanceof Error ? launchResult.error.message : "Treeport could not start the update process.";
+				throw new DomainError("APPLICATION_UPDATE_START_FAILED", "Treeport could not start the update process.", 500);
+			}
+			return status();
+		},
+		dispose() {
+			disposed = true;
+			pollingStarted = false;
+			if (pollTimer) {
+				clearTimeout(pollTimer);
+				pollTimer = null;
+			}
+		}
+	};
+}
+//#endregion
 //#region src/server/daemon-ownership.ts
 function processExists(pid) {
 	try {
@@ -8361,7 +8872,7 @@ var TerminalAttachmentManager = class {
 			catch: (cause) => new AttachmentInitializationError(phase, cause)
 		});
 		return Effect.gen(this, function* () {
-			const terminal = yield* promisePhase("refresh_terminal", () => this.service.refreshTerminalStatus(connection.terminalId));
+			const terminal = yield* promisePhase("refresh_terminal", () => this.service.refreshTerminalStatus(connection.terminalId, false));
 			if (!isInitializing()) return;
 			if (terminal.status === "missing") return yield* Effect.fail(new AttachmentInitializationError("refresh_terminal", /* @__PURE__ */ new Error("The tmux session for this terminal is missing")));
 			const worktree = yield* promisePhase("resolve_worktree", () => this.service.getWorktree(terminal.worktreeId));
@@ -8370,12 +8881,12 @@ var TerminalAttachmentManager = class {
 			const initialDimensions = yield* Effect.tryPromise({
 				try: () => this.enqueueTerminal(connection.terminalId, async () => {
 					if (!isInitializing()) return null;
+					const current = this.dimensions.get(connection.terminalId);
+					if (current) return current;
 					await this.tmux.useManualWindowSize(worktree.tmuxSocketName, terminal.tmuxSessionName).catch((cause) => {
 						throw new AttachmentInitializationError("configure_window_size", cause);
 					});
 					if (!isInitializing()) return null;
-					const current = this.dimensions.get(connection.terminalId);
-					if (current) return current;
 					const sessionSize = await this.tmux.sessionSize(worktree.tmuxSocketName, terminal.tmuxSessionName).catch((cause) => {
 						throw new AttachmentInitializationError("read_session_size", cause);
 					});
@@ -8867,107 +9378,126 @@ function createSocketServer(httpServer, { service, config, tmux, terminalMetadat
 }
 //#endregion
 //#region src/server/index.ts
-const config = loadConfig();
-const ownership = await acquireDaemonOwnership(config);
-const prerequisites = await checkRuntimePrerequisites(config);
-const runner = new SpawnCommandRunner();
-const database = await openDatabase(config.databasePath, { backupDirectory: path.join(config.dataDir, "database-backups") });
-const git = new GitAdapter(runner, config.gitPath);
-const launcherPath = fileURLToPath(new URL("./core/launcher.js", import.meta.url));
-const tmux = new TmuxAdapter(runner, config.runtimeDir, config.tmuxPath, launcherPath);
-const service = new TreeportService({
-	config,
-	database,
-	runner,
-	git,
-	tmux,
-	gh: new GhAdapter(runner, config.ghPath)
-});
-await service.initialize();
-const terminalMetadata = new TerminalMetadataManager(service, tmux, config.tmuxPath);
-await terminalMetadata.initialize();
-const honoListener = getRequestListener(createApp({
-	service,
-	config,
-	tmux,
-	terminalMetadata
-}).fetch);
-let vite = null;
-const server = createServer((request, response) => {
-	const security = authorizeRequest(request);
-	if (!security.allowed) {
-		rejectHttpRequest(request, response, security);
-		return;
-	}
-	service.handleWebPanelDevelopmentRequest(request, response, () => {
-		if (vite && !request.url?.startsWith("/api")) {
-			vite.middlewares(request, response, () => {
+async function main() {
+	const config = loadConfig();
+	const updateStartup = await createUpdateStartupReporter(config);
+	try {
+		const ownership = await acquireDaemonOwnership(config);
+		const prerequisites = await checkRuntimePrerequisites(config);
+		const runner = new SpawnCommandRunner();
+		await updateStartup.databaseOpening();
+		const database = await openDatabase(config.databasePath, { backupDirectory: path.join(config.dataDir, "database-backups") });
+		await updateStartup.databaseOpened({
+			migrationState: database.migrationState,
+			snapshotPaths: database.migrationSnapshotPaths
+		});
+		const git = new GitAdapter(runner, config.gitPath);
+		const launcherPath = fileURLToPath(new URL("./core/launcher.js", import.meta.url));
+		const tmux = new TmuxAdapter(runner, config.runtimeDir, config.tmuxPath, launcherPath);
+		const service = new TreeportService({
+			config,
+			database,
+			runner,
+			git,
+			tmux,
+			gh: new GhAdapter(runner, config.ghPath)
+		});
+		await service.initialize();
+		const terminalMetadata = new TerminalMetadataManager(service, tmux, config.tmuxPath);
+		await terminalMetadata.initialize();
+		const applicationUpdate = createApplicationUpdateManager(config);
+		const honoListener = getRequestListener(createApp({
+			service,
+			config,
+			tmux,
+			applicationUpdate,
+			terminalMetadata
+		}).fetch);
+		let vite = null;
+		const server = createServer((request, response) => {
+			const security = authorizeRequest(request);
+			if (!security.allowed) {
+				rejectHttpRequest(request, response, security);
+				return;
+			}
+			service.handleWebPanelDevelopmentRequest(request, response, () => {
+				if (vite && !request.url?.startsWith("/api")) {
+					vite.middlewares(request, response, () => {
+						honoListener(request, response);
+					});
+					return;
+				}
 				honoListener(request, response);
 			});
-			return;
-		}
-		honoListener(request, response);
-	});
-});
-server.on("upgrade", (request, socket) => {
-	const security = authorizeRequest(request, { socketUpgrade: true });
-	if (security.allowed) return;
-	const statusText = security.status === 400 ? "Bad Request" : security.status === 403 ? "Forbidden" : "Unauthorized";
-	socket.write(`HTTP/1.1 ${security.status} ${statusText}\r\nConnection: close\r\nCache-Control: no-store\r\n\r\n`);
-	socket.destroy();
-});
-if (config.webDevelopment) {
-	const { createServer: createViteServer } = await import("vite");
-	vite = await createViteServer({
-		configFile: path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../vite.config.ts"),
-		appType: "spa",
-		server: {
-			middlewareMode: true,
-			hmr: { server }
+		});
+		server.on("upgrade", (request, socket) => {
+			const security = authorizeRequest(request, { socketUpgrade: true });
+			if (security.allowed) return;
+			const statusText = security.status === 400 ? "Bad Request" : security.status === 403 ? "Forbidden" : "Unauthorized";
+			socket.write(`HTTP/1.1 ${security.status} ${statusText}\r\nConnection: close\r\nCache-Control: no-store\r\n\r\n`);
+			socket.destroy();
+		});
+		if (config.webDevelopment) {
+			const { createServer: createViteServer } = await import("vite");
+			vite = await createViteServer({
+				configFile: path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../vite.config.ts"),
+				appType: "spa",
+				server: {
+					middlewareMode: true,
+					hmr: { server }
+				}
+			});
 		}
-	});
-}
-service.attachHttpServer(server);
-const { io, attachments } = createSocketServer(server, {
-	service,
-	config,
-	tmux,
-	terminalMetadata
-});
-await new Promise((resolve, reject) => {
-	server.once("error", reject);
-	server.listen(config.port, config.host, () => {
-		server.off("error", reject);
-		resolve();
-	});
-});
-await ownership.publish();
-console.log(`Treeport ${config.appVersion} listening on ${config.apiUrl}`);
-console.log(`database: ${config.databasePath}`);
-console.log(`git: ${prerequisites.gitVersion}`);
-console.log(`tmux: ${prerequisites.tmuxVersion}`);
-let shuttingDown = false;
-function shutdown() {
-	if (shuttingDown) return;
-	shuttingDown = true;
-	attachments.dispose();
-	terminalMetadata.dispose();
-	const viteClosed = vite?.close();
-	io.close(() => {
-		Promise.all([
-			service.drainMutations(),
-			terminalMetadata.drain(),
-			viteClosed
-		]).then(async () => {
-			await service.disposeWebPanelRuntime();
-			database.close();
-			await ownership.release();
-			process.exit(0);
+		service.attachHttpServer(server);
+		const { io, attachments } = createSocketServer(server, {
+			service,
+			config,
+			tmux,
+			terminalMetadata
 		});
-	});
-	setTimeout(() => process.exit(1), 5e3).unref();
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(config.port, config.host, () => {
+				server.off("error", reject);
+				resolve();
+			});
+		});
+		await ownership.publish();
+		await updateStartup.ready();
+		applicationUpdate.beginPolling();
+		console.log(`Treeport ${config.appVersion} listening on ${config.apiUrl}`);
+		console.log(`database: ${config.databasePath}`);
+		console.log(`git: ${prerequisites.gitVersion}`);
+		console.log(`tmux: ${prerequisites.tmuxVersion}`);
+		let shuttingDown = false;
+		function shutdown() {
+			if (shuttingDown) return;
+			shuttingDown = true;
+			applicationUpdate.dispose();
+			attachments.dispose();
+			terminalMetadata.dispose();
+			const viteClosed = vite?.close();
+			io.close(() => {
+				Promise.all([
+					service.drainMutations(),
+					terminalMetadata.drain(),
+					viteClosed
+				]).then(async () => {
+					await service.disposeWebPanelRuntime();
+					database.close();
+					await ownership.release();
+					process.exit(0);
+				});
+			});
+			setTimeout(() => process.exit(1), 5e3).unref();
+		}
+		process.once("SIGINT", shutdown);
+		process.once("SIGTERM", shutdown);
+	} catch (error) {
+		await updateStartup.failed(error instanceof Error ? error : new Error(String(error)));
+		throw error;
+	}
 }
-process.once("SIGINT", shutdown);
-process.once("SIGTERM", shutdown);
+await main();
 //#endregion
 export {};