@agent-team-foundation/first-tree-hub 0.8.5 → 0.9.0

package/dist/{core-DoIprl2f.mjs → core-DZDhomaN.mjs}

@@ -1,9 +1,10 @@
-import { m as __toESM } from "./esm-CYu4tXXn.mjs";
-import { C as setConfigValue, S as serverConfigSchema, _ as loadAgents, d as DEFAULT_HOME_DIR$1, f as agentConfigSchema, g as initConfig, i as loadCredentials, l as DEFAULT_CONFIG_DIR, m as collectMissingPrompts, n as ensureFreshAccessToken, o as resolveServerUrl, p as clientConfigSchema, s as saveAgentConfig, u as DEFAULT_DATA_DIR$1, x as resolveConfigReadonly } from "./bootstrap-99vUYmLs.mjs";
+import { f as __require, l as __commonJSMin, m as __toESM } from "./esm-CYu4tXXn.mjs";
+import { C as serverConfigSchema, S as resolveConfigReadonly, _ as loadAgents, d as DEFAULT_HOME_DIR$1, f as agentConfigSchema, g as initConfig, i as loadCredentials, l as DEFAULT_CONFIG_DIR, m as collectMissingPrompts, n as ensureFreshAccessToken, o as resolveServerUrl, p as clientConfigSchema, s as saveAgentConfig, u as DEFAULT_DATA_DIR$1, v as migrateLegacyHome, w as setConfigValue } from "./bootstrap-CWcBzk6C.mjs";
 import { _ as withSpan, a as endWsConnectionSpan, b as require_pino, c as messageAttrs, d as rootLogger$1, g as startWsConnectionSpan, i as currentTraceId, n as applyLoggerConfig, o as getFastifyOtelPlugin, p as setWsConnectionAttrs, r as createLogger, t as adapterAttrs, u as observabilityPlugin, v as withWsMessageSpan, y as FIRST_TREE_HUB_ATTR } from "./observability-CJzDFY_G-CmvgUuzc.mjs";
-import { $ as updateAdapterConfigSchema, A as createMemberSchema, B as notificationQuerySchema, C as agentTypeSchema$1, D as createAdapterMappingSchema, E as createAdapterConfigSchema, F as inboxPollQuerySchema, G as sendMessageSchema, H as refreshTokenSchema, I as isRedactedEnvValue, J as sessionEventMessageSchema, K as sendToAgentSchema, L as linkTaskChatSchema, M as createTaskSchema, N as delegateFeishuUserSchema, O as createAgentSchema, P as dryRunAgentRuntimeConfigSchema, Q as taskListQuerySchema, R as loginSchema, S as agentRuntimeConfigPayloadSchema$1, T as connectTokenExchangeSchema, U as runtimeStateMessageSchema, V as paginationQuerySchema, W as selfServiceFeishuBotSchema, X as sessionReconcileRequestSchema, Y as sessionEventSchema$1, Z as sessionStateMessageSchema, _ as addParticipantSchema, a as AGENT_SELECTOR_HEADER$1, at as updateSystemConfigSchema, b as agentBindRequestSchema, c as AGENT_TYPES, d as SYSTEM_CONFIG_DEFAULTS, et as updateAgentRuntimeConfigSchema, f as TASK_CREATOR_TYPES, g as WS_AUTH_FRAME_TIMEOUT_MS, h as TASK_TERMINAL_STATUSES, i as AGENT_BIND_REJECT_REASONS, it as updateOrganizationSchema, j as createOrganizationSchema, k as createChatSchema, l as AGENT_VISIBILITY, m as TASK_STATUSES, nt as updateChatSchema, o as AGENT_SOURCES, ot as updateTaskStatusSchema, p as TASK_HEALTH_SIGNALS, q as sessionCompletionMessageSchema, rt as updateMemberSchema, s as AGENT_STATUSES, st as wsAuthFrameSchema, tt as updateAgentSchema, u as DEFAULT_AGENT_RUNTIME_CONFIG_PAYLOAD, v as adminCreateTaskSchema, w as clientRegisterSchema, x as agentPinnedMessageSchema$1, y as adminUpdateTaskSchema, z as messageSourceSchema$1 } from "./feishu-n9Y2yGTT.mjs";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { $ as updateAdapterConfigSchema, A as createMemberSchema, B as notificationQuerySchema, C as agentTypeSchema$1, D as createAdapterMappingSchema, E as createAdapterConfigSchema, F as inboxPollQuerySchema, G as sendMessageSchema, H as refreshTokenSchema, I as isRedactedEnvValue, J as sessionEventMessageSchema, K as sendToAgentSchema, L as linkTaskChatSchema, M as createTaskSchema, N as delegateFeishuUserSchema, O as createAgentSchema, P as dryRunAgentRuntimeConfigSchema, Q as taskListQuerySchema, R as loginSchema, S as agentRuntimeConfigPayloadSchema$1, T as connectTokenExchangeSchema, U as runtimeStateMessageSchema, V as paginationQuerySchema, W as selfServiceFeishuBotSchema, X as sessionReconcileRequestSchema, Y as sessionEventSchema$1, Z as sessionStateMessageSchema, _ as addParticipantSchema, a as AGENT_SELECTOR_HEADER$1, at as updateSystemConfigSchema, b as agentBindRequestSchema, c as AGENT_TYPES, d as SYSTEM_CONFIG_DEFAULTS, et as updateAgentRuntimeConfigSchema, f as TASK_CREATOR_TYPES, g as WS_AUTH_FRAME_TIMEOUT_MS, h as TASK_TERMINAL_STATUSES, i as AGENT_BIND_REJECT_REASONS, it as updateOrganizationSchema, j as createOrganizationSchema, k as createChatSchema, l as AGENT_VISIBILITY, m as TASK_STATUSES, nt as updateChatSchema, o as AGENT_SOURCES, ot as updateTaskStatusSchema, p as TASK_HEALTH_SIGNALS, q as sessionCompletionMessageSchema, rt as updateMemberSchema, s as AGENT_STATUSES, st as wsAuthFrameSchema, tt as updateAgentSchema, u as DEFAULT_AGENT_RUNTIME_CONFIG_PAYLOAD, v as adminCreateTaskSchema, w as clientRegisterSchema, x as agentPinnedMessageSchema$1, y as adminUpdateTaskSchema, z as messageSourceSchema$1 } from "./feishu-GlaczcVf.mjs";
+import { createRequire } from "node:module";
+import { copyFileSync, createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { ZodError, z } from "zod";
 import { Writable } from "node:stream";
 import { stringify } from "yaml";
@@ -13,13 +14,14 @@ import { EventEmitter } from "node:events";
 import WebSocket from "ws";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { execFileSync, execSync, spawn, spawnSync } from "node:child_process";
+import * as semver from "semver";
 import bcrypt from "bcrypt";
 import { and, asc, count, desc, eq, gt, inArray, isNotNull, isNull, lt, ne, or, sql } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import { fileURLToPath } from "node:url";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
-import { input, password, select } from "@inquirer/prompts";
+import { confirm, input, password, select } from "@inquirer/prompts";
 import cors from "@fastify/cors";
 import rateLimit from "@fastify/rate-limit";
 import fastifyStatic from "@fastify/static";
@@ -959,6 +961,18 @@ z.object({
 	type: z.literal("auth"),
 	token: z.string().min(1)
 });
+/**
+* Advisory frame sent server → client immediately after `auth:ok`. It carries
+* the Command-package version the server was bundled with, so the client can
+* detect version drift on startup and on each reconnect. `.passthrough()` so
+* future server versions may add fields without breaking older clients that
+* validate this frame.
+*/
+const serverWelcomeFrameSchema = z.object({
+	type: z.literal("server:welcome"),
+	serverCommandVersion: z.string().min(1),
+	serverTimeMs: z.number().int().nonnegative()
+}).passthrough();
 const FETCH_TIMEOUT_MS = 15e3;
 var FirstTreeHubSDK = class {
 	_baseUrl;
@@ -1132,6 +1146,8 @@ var ClientConnection = class extends EventEmitter {
 	reconnectAttempt = 0;
 	closing = false;
 	registered = false;
+	/** Count of `server:welcome` frames received; drives `isReconnect` flag. */
+	welcomeFramesReceived = 0;
 	boundAgents = /* @__PURE__ */ new Map();
 	/** Agents scheduled to rebind automatically on every reconnect. */
 	desiredBindings = /* @__PURE__ */ new Map();
@@ -1324,6 +1340,20 @@ var ClientConnection = class extends EventEmitter {
 			}));
 			return;
 		}
+		if (type === "server:welcome") {
+			const parsed = serverWelcomeFrameSchema.safeParse(msg);
+			if (!parsed.success) {
+				process.stderr.write(`[ClientConnection] Ignoring malformed server:welcome frame: ${parsed.error.issues.map((i) => i.message).join(", ")}\n`);
+				return;
+			}
+			const isReconnect = this.welcomeFramesReceived > 0;
+			this.welcomeFramesReceived++;
+			this.emit("server:welcome", {
+				frame: parsed.data,
+				isReconnect
+			});
+			return;
+		}
 		if (type === "auth:rejected" || type === "auth:expired") {
 			if (type === "auth:expired") this.emit("auth:expired");
 			this.ws?.close(4401, type);
@@ -1552,6 +1582,24 @@ defineConfig({
 		max_sessions: field(z.number().int().positive().default(10))
 	}
 });
+/**
+* Phase-dependent defaults that flip with release milestones. Kept as a plain
+* module-level constant so reviews of the beta→GA transition are a one-line
+* diff, and so tests can mock this module to exercise both branches.
+*/
+const UPDATE_POLICIES = [
+	"auto",
+	"prompt",
+	"off"
+];
+/**
+* Default value of `update.policy` on the Client config. During the beta this
+* is `"auto"` — operators rarely know to `npm i -g` weekly and we chase the
+* latest published Command by default. The GA PR flips it to `"prompt"` and
+* bumps Command to `1.0.0`.
+*/
+const UPDATE_POLICY_DEFAULT = "auto";
+const updatePolicySchema = z.enum(UPDATE_POLICIES);
 defineConfig({
 	server: { url: field(z.string(), {
 		env: "FIRST_TREE_HUB_SERVER_URL",
@@ -1564,11 +1612,18 @@ defineConfig({
 		auto: "client-id",
 		env: "FIRST_TREE_HUB_CLIENT_ID"
 	}) },
+	update: {
+		policy: field(updatePolicySchema.default(UPDATE_POLICY_DEFAULT), { env: "FIRST_TREE_HUB_UPDATE_POLICY" }),
+		restart_quiet_seconds: field(z.number().int().min(1).max(3600).default(30), { env: "FIRST_TREE_HUB_UPDATE_RESTART_QUIET_SECONDS" }),
+		restart_check_interval_seconds: field(z.number().int().min(5).max(300).default(10), { env: "FIRST_TREE_HUB_UPDATE_RESTART_CHECK_INTERVAL_SECONDS" }),
+		prompt_timeout_seconds: field(z.number().int().min(10).max(600).default(60), { env: "FIRST_TREE_HUB_UPDATE_PROMPT_TIMEOUT_SECONDS" })
+	},
 	logLevel: field(logLevelSchema.default("info"), { env: "FIRST_TREE_HUB_LOG_LEVEL" })
 });
-const DEFAULT_HOME_DIR = process.env.FIRST_TREE_HUB_HOME ?? join(homedir(), ".first-tree-hub");
+const DEFAULT_HOME_DIR = process.env.FIRST_TREE_HUB_HOME ?? join(homedir(), ".first-tree", "hub");
 join(DEFAULT_HOME_DIR, "config");
 const DEFAULT_DATA_DIR = join(DEFAULT_HOME_DIR, "data");
+join(homedir(), ".first-tree-hub");
 defineConfig({
 	database: {
 		url: field(z.string(), {
@@ -3235,6 +3290,20 @@ var SessionManager = class {
 	get totalCount() {
 		return this.sessions.size;
 	}
+	/**
+	* Snapshot used by the UpdateManager's quiet gate to decide whether it is
+	* safe to exit the process for a self-update. `activeCount` is the number of
+	* sessions currently handling a message; `lastActivityMs` is the most recent
+	* activity timestamp across all tracked sessions (0 when there are none).
+	*/
+	getQuietGateSnapshot() {
+		let lastActivityMs = 0;
+		for (const entry of this.sessions.values()) if (entry.lastActivity > lastActivityMs) lastActivityMs = entry.lastActivity;
+		return {
+			activeCount: this._activeCount,
+			lastActivityMs
+		};
+	}
 	/** Return the current aggregate runtime state, or null if no sessions have reported. */
 	getAggregateRuntimeState() {
 		return this.lastReportedRuntimeState;
@@ -3558,6 +3627,17 @@ var AgentSlot = class {
 	get clientConnection() {
 		return this.config.clientConnection;
 	}
+	/**
+	* Snapshot of this slot's busy/idle state used by the UpdateManager's
+	* quiet gate. Returns zeros before `start()` has built the session manager,
+	* which is the same semantics: idle.
+	*/
+	getQuietGateSnapshot() {
+		return this.sessionManager?.getQuietGateSnapshot() ?? {
+			activeCount: 0,
+			lastActivityMs: 0
+		};
+	}
 	async start(contextTreePath) {
 		const sdk = (await this.clientConnection.bindAgent(this.config.agentId, this.config.runtimeType ?? this.config.type, this.config.runtimeVersion)).sdk;
 		this.sdk = sdk;
@@ -3741,6 +3821,147 @@ z.object({
 	server: z.url().default("http://localhost:8000"),
 	agents: z.record(z.string(), agentSlotConfigSchema).refine((agents) => Object.keys(agents).length > 0, "At least one agent must be defined")
 });
+/**
+* Version-drift decision flow. Install, prompt, and exit are delegated to
+* command-layer callbacks so the Client package stays free of CLI /
+* filesystem knowledge.
+*/
+var UpdateManager = class UpdateManager {
+	options;
+	connection;
+	welcomeListener;
+	updateInFlight = false;
+	quietGateTimer = null;
+	disposed = false;
+	/**
+	* Set when a standalone (unmanaged) executeUpdate reports `installed: true`
+	* without exiting. The new bits are on disk; subsequent welcome frames must
+	* not re-invoke npm since a restart is the only way to pick them up.
+	*/
+	pendingRestart = false;
+	constructor(connection, options) {
+		this.connection = connection;
+		this.options = options;
+		this.welcomeListener = (welcome) => {
+			this.onWelcome(welcome).catch((err) => {
+				const msg = err instanceof Error ? err.message : String(err);
+				this.options.log("warn", `update decision failed: ${msg}`);
+			});
+		};
+	}
+	/** Attach a manager to a connection. Returns the instance so callers can dispose. */
+	static attach(connection, options) {
+		const mgr = new UpdateManager(connection, options);
+		connection.on("server:welcome", mgr.welcomeListener);
+		return mgr;
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.connection.off("server:welcome", this.welcomeListener);
+		if (this.quietGateTimer) {
+			clearTimeout(this.quietGateTimer);
+			this.quietGateTimer = null;
+		}
+	}
+	async onWelcome(welcome) {
+		if (this.disposed || this.updateInFlight || this.pendingRestart) return;
+		this.updateInFlight = true;
+		try {
+			await this.decide(welcome);
+		} finally {
+			this.updateInFlight = false;
+		}
+	}
+	async decide(welcome) {
+		const { serverCommandVersion: target } = welcome.frame;
+		const current = this.options.currentVersion;
+		if (!semver.valid(target)) {
+			this.options.log("warn", `Server advertised invalid version "${target}"; skipping drift check`);
+			return;
+		}
+		if (!semver.valid(current)) {
+			this.options.log("warn", `Own version "${current}" is not valid SemVer; skipping drift check`);
+			return;
+		}
+		if (semver.eq(target, current)) {
+			this.options.log("debug", `Server advertises ${target}, matching running version`);
+			return;
+		}
+		if (semver.lt(target, current)) {
+			this.options.log("info", `Server advertises ${target}, running ${current} (ahead)`);
+			return;
+		}
+		const policy = this.options.updateConfig.policy;
+		if (policy === "off") {
+			this.options.log("info", `Server advertises ${target}, running ${current}; self-update disabled (policy=off)`);
+			return;
+		}
+		if (policy === "prompt") {
+			if (!this.options.isTTY) {
+				this.options.log("warn", `Update available (${current} → ${target}) but policy=prompt requires a terminal; operator action required`);
+				return;
+			}
+			if (!await this.options.prompt({
+				currentVersion: current,
+				targetVersion: target,
+				timeoutSeconds: this.options.updateConfig.prompt_timeout_seconds
+			})) {
+				this.options.log("info", `Update declined by operator (still running ${current})`);
+				return;
+			}
+			await this.runUpdate(current, target);
+			return;
+		}
+		this.options.log("info", `Server advertises ${target}, running ${current}; policy=auto`);
+		if (this.options.isTTY) {
+			this.options.log("info", "Auto-update starting in 5s");
+			await sleep(5e3);
+			if (this.disposed) return;
+		}
+		if (welcome.isReconnect) {
+			await this.waitForQuietGate();
+			if (this.disposed) return;
+		}
+		await this.runUpdate(current, target);
+	}
+	async waitForQuietGate() {
+		const quietMs = this.options.updateConfig.restart_quiet_seconds * 1e3;
+		const intervalMs = this.options.updateConfig.restart_check_interval_seconds * 1e3;
+		while (!this.disposed) {
+			const snapshot = this.options.getQuietGateSnapshot();
+			const now = Date.now();
+			const idleFor = snapshot.lastActivityMs === 0 ? Number.POSITIVE_INFINITY : now - snapshot.lastActivityMs;
+			if (snapshot.activeCount === 0 && idleFor >= quietMs) return;
+			this.options.log("debug", `Quiet gate: activeCount=${snapshot.activeCount}, idleFor=${Math.round(idleFor)}ms; re-checking in ${intervalMs}ms`);
+			await new Promise((resolve) => {
+				this.quietGateTimer = setTimeout(() => {
+					this.quietGateTimer = null;
+					resolve();
+				}, intervalMs);
+			});
+		}
+	}
+	async runUpdate(current, target) {
+		try {
+			if ((await this.options.executeUpdate({
+				currentVersion: current,
+				targetVersion: target
+			})).installed) {
+				this.pendingRestart = true;
+				this.options.log("info", `Update ${target} installed; restart required to pick it up (no further self-update attempts until restart)`);
+				return;
+			}
+			this.options.log("warn", "Self-update did not complete; will retry on next welcome frame");
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this.options.log("warn", `Self-update threw: ${msg}`);
+		}
+	}
+};
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
 //#endregion
 //#region src/core/admin.ts
 /**
@@ -3841,6 +4062,8 @@ var ClientRuntime = class {
 	agents = [];
 	agentNames = /* @__PURE__ */ new Set();
 	agentIds = /* @__PURE__ */ new Set();
+	options;
+	updateManager = null;
 	watcher = null;
 	debounceTimer = null;
 	/**
@@ -3849,11 +4072,13 @@ var ClientRuntime = class {
 	* `agent:pinned` handler knows where to materialise new configs.
 	*/
 	agentsDir = null;
-	constructor(serverUrl, clientId) {
+	constructor(serverUrl, clientId, options = {}) {
 		this.serverUrl = serverUrl;
+		this.options = options;
 		this.connection = new ClientConnection({
 			serverUrl,
 			clientId,
+			sdkVersion: options.currentVersion,
 			getAccessToken: () => ensureFreshAccessToken()
 		});
 		registerBuiltinHandlers();
@@ -3892,6 +4117,13 @@ var ClientRuntime = class {
 		this.agentIds.add(config.agentId);
 	}
 	async start() {
+		if (this.options.currentVersion && this.options.update) this.updateManager = UpdateManager.attach(this.connection, {
+			currentVersion: this.options.currentVersion,
+			...this.options.update,
+			isTTY: Boolean(process.stdout.isTTY),
+			log: (level, msg) => process.stderr.write(`  [update/${level}] ${msg}\n`),
+			getQuietGateSnapshot: () => this.aggregateQuietGate()
+		});
 		await this.connection.connect();
 		process.stderr.write(`  \u2713 Client registered: ${this.connection.clientId}\n`);
 		if (this.agents.length === 0) {
@@ -3935,9 +4167,24 @@ var ClientRuntime = class {
 	}
 	async stop() {
 		this.unwatchAgentsDir();
+		this.updateManager?.dispose();
+		this.updateManager = null;
 		await Promise.allSettled(this.agents.map((a) => a.slot.stop()));
 		await this.connection.disconnect();
 	}
+	aggregateQuietGate() {
+		let activeCount = 0;
+		let lastActivityMs = 0;
+		for (const entry of this.agents) {
+			const snap = entry.slot.getQuietGateSnapshot();
+			activeCount += snap.activeCount;
+			if (snap.lastActivityMs > lastActivityMs) lastActivityMs = snap.lastActivityMs;
+		}
+		return {
+			activeCount,
+			lastActivityMs
+		};
+	}
 	scanForNewAgents(agentsDir) {
 		try {
 			const all = loadAgents({
@@ -4506,136 +4753,570 @@ async function runMigrations(databaseUrl) {
 	}
 }
 //#endregion
-//#region src/core/onboard.ts
-const STATE_FILE = join(DEFAULT_HOME_DIR$1, ".onboard-state.json");
-/** Save current onboard args to state file for resume. */
-function saveOnboardState(args) {
-	mkdirSync(DEFAULT_HOME_DIR$1, { recursive: true });
-	writeFileSync(STATE_FILE, JSON.stringify({ args }, null, 2));
+//#region src/core/service-install.ts
+/**
+* Run a subprocess capturing stderr so failures surface a meaningful error
+* instead of Node's opaque "Command failed". Used for launchctl/systemctl —
+* anywhere the stderr message is diagnostically crucial.
+*/
+function runCapture(program, args, timeoutMs) {
+	const res = spawnSync(program, args, {
+		encoding: "utf-8",
+		timeout: timeoutMs,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	if (res.status === 0) return { ok: true };
+	return {
+		ok: false,
+		stderr: (res.stderr ?? "").trim(),
+		code: res.status
+	};
 }
-/** Load saved onboard args from state file. */
-function loadOnboardState() {
+function sleepSync(ms) {
+	const shared = new Int32Array(new SharedArrayBuffer(4));
+	Atomics.wait(shared, 0, 0, ms);
+}
+const LAUNCHD_LABEL = "dev.first-tree-hub.client";
+const SYSTEMD_UNIT = "first-tree-hub-client.service";
+const LOG_DIR = join(DEFAULT_HOME_DIR$1, "logs");
+function whichBin(name) {
 	try {
-		return JSON.parse(readFileSync(STATE_FILE, "utf-8")).args;
+		return execFileSync(process.platform === "win32" ? "where" : "which", [name], {
+			encoding: "utf-8",
+			timeout: 3e3
+		}).split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0] ?? null;
 	} catch {
 		return null;
 	}
 }
-async function onboardCheck(args) {
-	const items = [];
-	const creds = loadCredentials();
-	if (creds) items.push({
-		key: "connect",
-		label: "Signed in",
-		status: "ok",
-		value: creds.serverUrl
-	});
-	else items.push({
-		key: "connect",
-		label: "Signed in",
-		status: "missing_required",
-		hint: "Run `first-tree-hub client connect <server-url>` first"
-	});
-	try {
-		const serverUrl = resolveServerUrl(args.server);
-		items.push({
-			key: "server",
-			label: "Server URL",
-			status: "ok",
-			value: serverUrl
-		});
-		try {
-			const res = await fetch(`${serverUrl}/api/v1/health`);
-			items.push({
-				key: "server_reachable",
-				label: "Server reachable",
-				status: res.ok ? "ok" : "error",
-				value: res.ok ? "healthy" : `HTTP ${res.status}`
-			});
-		} catch {
-			items.push({
-				key: "server_reachable",
-				label: "Server reachable",
-				status: "error",
-				hint: "Cannot connect to server"
-			});
-		}
+/**
+* Resolve how the service should launch the CLI.
+*
+* Prefers the installed `first-tree-hub` bin on PATH (usually a shim under
+* /usr/local/bin or ~/.npm-global/bin). Falls back to invoking the current
+* Node interpreter against the running script (handles `pnpm dev`, tsx, and
+* dev-only global installs).
+*/
+function resolveCliInvocation() {
+	const bin = whichBin("first-tree-hub");
+	if (bin && isAbsolute(bin)) try {
+		return {
+			kind: "bin",
+			program: realpathSync(bin)
+		};
 	} catch {
-		items.push({
-			key: "server",
-			label: "Server URL",
-			status: "missing_required",
-			hint: "Provide via --server, FIRST_TREE_HUB_SERVER_URL, or config"
-		});
-	}
-	if (args.id) items.push({
-		key: "id",
-		label: "Agent ID",
-		status: "ok",
-		value: args.id
-	});
-	else items.push({
-		key: "id",
-		label: "Agent ID",
-		status: "missing_required",
-		hint: "Provide via --id"
-	});
-	if (args.type) items.push({
-		key: "type",
-		label: "Agent type",
-		status: "ok",
-		value: args.type
-	});
-	else items.push({
-		key: "type",
-		label: "Agent type",
-		status: "missing_required",
-		hint: "Provide via --type"
-	});
-	if (args.type && args.type !== "human") if (args.clientId) items.push({
-		key: "client",
-		label: "Target client",
-		status: "ok",
-		value: args.clientId
-	});
-	else items.push({
-		key: "client",
-		label: "Target client",
-		status: "ok",
-		value: "(unbound — claimed on first WS connect)"
-	});
-	return items;
-}
-function formatCheckReport(items) {
-	const lines = [];
-	for (const item of items) {
-		const icon = item.status === "ok" ? "✅" : item.status === "missing_required" ? "❌" : item.status === "error" ? "❌" : item.status === "warning" ? "⚠️" : "⬜";
-		const valueStr = item.value ? `  ${item.value}` : "";
-		const hintStr = item.hint ? `  (${item.hint})` : "";
-		lines.push(`  ${icon} ${item.label.padEnd(20)}${valueStr}${hintStr}`);
+		return {
+			kind: "bin",
+			program: bin
+		};
 	}
-	return lines.join("\n");
+	const script = process.argv[1];
+	if (!script) throw new Error("Cannot resolve CLI entry point (process.argv[1] is empty).");
+	const scriptAbs = isAbsolute(script) ? script : join(process.cwd(), script);
+	return {
+		kind: "node",
+		program: process.execPath,
+		args: [scriptAbs]
+	};
 }
-async function createAgentViaAdmin(serverUrl, accessToken, body) {
-	const res = await fetch(`${serverUrl}/api/v1/admin/agents`, {
-		method: "POST",
-		headers: {
-			Authorization: `Bearer ${accessToken}`,
-			"Content-Type": "application/json"
-		},
-		body: JSON.stringify(body),
-		signal: AbortSignal.timeout(1e4)
+function ensureLogDir() {
+	mkdirSync(LOG_DIR, {
+		recursive: true,
+		mode: 448
 	});
-	if (!res.ok) {
-		const errBody = await res.json().catch(() => ({}));
-		throw new Error(errBody.error ?? `Failed to create agent (HTTP ${res.status})`);
-	}
-	return await res.json();
 }
-async function onboardCreate(args) {
-	const serverUrl = resolveServerUrl(args.server).replace(/\/+$/, "");
-	const accessToken = await ensureFreshAccessToken();
-	const metadata = {};
+function launchdPlistPath() {
+	return join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function renderPlist(invocation) {
+	const argsXml = (invocation.kind === "bin" ? [
+		invocation.program,
+		"client",
+		"start",
+		"--no-interactive"
+	] : [
+		invocation.program,
+		...invocation.args,
+		"client",
+		"start",
+		"--no-interactive"
+	]).map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+	const outLog = join(LOG_DIR, "client.out.log");
+	const errLog = join(LOG_DIR, "client.err.log");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTD/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(outLog)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(errLog)}</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function launchctlDomainTarget() {
+	return `gui/${userInfo().uid}`;
+}
+function launchdState() {
+	if (!existsSync(launchdPlistPath())) return { state: "not-installed" };
+	const res = spawnSync("launchctl", ["print", `${launchctlDomainTarget()}/${LAUNCHD_LABEL}`], {
+		encoding: "utf-8",
+		timeout: 5e3,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	if (res.status !== 0) return {
+		state: "inactive",
+		detail: "plist present but not loaded"
+	};
+	const out = res.stdout ?? "";
+	const stateLine = out.split(/\r?\n/).find((l) => l.trim().startsWith("state ="));
+	const pidLine = out.split(/\r?\n/).find((l) => l.trim().startsWith("pid ="));
+	if (stateLine?.includes("running")) {
+		const pid = pidLine?.split("=")[1]?.trim();
+		return {
+			state: "active",
+			detail: pid ? `pid ${pid}` : "running"
+		};
+	}
+	return {
+		state: "inactive",
+		detail: stateLine?.trim() ?? "loaded"
+	};
+}
+/**
+* Poll `launchctl print` until the label disappears, confirming launchd has
+* finished the async eviction kicked off by `bootout`. Required because
+* `bootout` returns before the actual unload completes when the service has
+* active WebSocket connections — a follow-up `bootstrap` against a still-
+* registered label fails with `Bootstrap failed: 5: Input/output error`.
+*/
+function waitForLabelEvicted(target, label, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		if (spawnSync("launchctl", ["print", `${target}/${label}`], {
+			encoding: "utf-8",
+			timeout: 2e3,
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			]
+		}).status !== 0) return true;
+		sleepSync(200);
+	}
+	return false;
+}
+function installLaunchd() {
+	const invocation = resolveCliInvocation();
+	ensureLogDir();
+	const plistPath = launchdPlistPath();
+	mkdirSync(dirname(plistPath), { recursive: true });
+	writeFileSync(plistPath, renderPlist(invocation), { mode: 420 });
+	const target = launchctlDomainTarget();
+	const bootoutRes = runCapture("launchctl", ["bootout", `${target}/${LAUNCHD_LABEL}`], 15e3);
+	if (!bootoutRes.ok) {
+		if (!/not find|no such|not loaded/i.test(bootoutRes.stderr)) process.stderr.write(`    warning: launchctl bootout: ${bootoutRes.stderr || `exit ${bootoutRes.code ?? "unknown"}`}\n`);
+	}
+	waitForLabelEvicted(target, LAUNCHD_LABEL, 1e4);
+	let lastBootstrapErr = null;
+	for (let attempt = 1; attempt <= 2; attempt++) {
+		const res = runCapture("launchctl", [
+			"bootstrap",
+			target,
+			plistPath
+		], 1e4);
+		if (res.ok) {
+			lastBootstrapErr = null;
+			break;
+		}
+		lastBootstrapErr = res;
+		if (attempt < 2) sleepSync(1e3);
+	}
+	if (lastBootstrapErr) throw new Error(`launchctl bootstrap failed: ${lastBootstrapErr.stderr || `exit ${lastBootstrapErr.code ?? "unknown"}`}\n    Command: launchctl bootstrap ${target} ${plistPath}\n    Recovery: \`launchctl bootout ${target}/${LAUNCHD_LABEL}\` then \`first-tree-hub service install\`.`);
+	const enableRes = runCapture("launchctl", ["enable", `${target}/${LAUNCHD_LABEL}`], 5e3);
+	if (!enableRes.ok) process.stderr.write(`    warning: launchctl enable: ${enableRes.stderr || `exit ${enableRes.code ?? "unknown"}`}\n`);
+	const { state, detail } = launchdState();
+	return {
+		platform: "launchd",
+		label: LAUNCHD_LABEL,
+		unitPath: plistPath,
+		logDir: LOG_DIR,
+		state,
+		detail
+	};
+}
+function uninstallLaunchd() {
+	const plistPath = launchdPlistPath();
+	const res = runCapture("launchctl", ["bootout", `${launchctlDomainTarget()}/${LAUNCHD_LABEL}`], 15e3);
+	if (!res.ok && !/not find|no such|not loaded/i.test(res.stderr)) process.stderr.write(`    warning: bootout during uninstall: ${res.stderr || `exit ${res.code ?? "unknown"}`}\n`);
+	if (existsSync(plistPath)) rmSync(plistPath);
+	return {
+		platform: "launchd",
+		label: LAUNCHD_LABEL,
+		unitPath: plistPath,
+		logDir: LOG_DIR,
+		state: "not-installed"
+	};
+}
+function systemdUnitPath() {
+	return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "systemd", "user", SYSTEMD_UNIT);
+}
+function renderSystemdUnit(invocation) {
+	return `[Unit]
+Description=First Tree Hub Client
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${invocation.kind === "bin" ? `${shellQuote(invocation.program)} client start --no-interactive` : `${shellQuote(invocation.program)} ${invocation.args.map(shellQuote).join(" ")} client start --no-interactive`}
+Restart=always
+RestartSec=10
+StandardOutput=append:${join(LOG_DIR, "client.out.log")}
+StandardError=append:${join(LOG_DIR, "client.err.log")}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target
+`;
+}
+function shellQuote(value) {
+	if (/^[A-Za-z0-9_\-./:=]+$/.test(value)) return value;
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function systemdState() {
+	if (!existsSync(systemdUnitPath())) return { state: "not-installed" };
+	const res = spawnSync("systemctl", [
+		"--user",
+		"is-active",
+		SYSTEMD_UNIT
+	], {
+		encoding: "utf-8",
+		timeout: 5e3,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const out = (res.stdout ?? "").trim();
+	if (res.status === 0 && out === "active") return {
+		state: "active",
+		detail: "running"
+	};
+	return {
+		state: "inactive",
+		detail: out || "unit present but not active"
+	};
+}
+function installSystemd() {
+	const invocation = resolveCliInvocation();
+	ensureLogDir();
+	const unitPath = systemdUnitPath();
+	mkdirSync(dirname(unitPath), { recursive: true });
+	writeFileSync(unitPath, renderSystemdUnit(invocation), { mode: 420 });
+	const reloadRes = runCapture("systemctl", ["--user", "daemon-reload"], 5e3);
+	if (!reloadRes.ok) throw new Error(`systemctl --user daemon-reload failed: ${reloadRes.stderr || `exit ${reloadRes.code ?? "unknown"}`}`);
+	const enableRes = runCapture("systemctl", [
+		"--user",
+		"enable",
+		"--now",
+		SYSTEMD_UNIT
+	], 1e4);
+	if (!enableRes.ok) throw new Error(`systemctl --user enable --now ${SYSTEMD_UNIT} failed: ${enableRes.stderr || `exit ${enableRes.code ?? "unknown"}`}\n    Recovery: \`systemctl --user stop ${SYSTEMD_UNIT}\` then \`first-tree-hub service install\`.`);
+	const { state, detail } = systemdState();
+	return {
+		platform: "systemd",
+		label: SYSTEMD_UNIT,
+		unitPath,
+		logDir: LOG_DIR,
+		state,
+		detail
+	};
+}
+function uninstallSystemd() {
+	const unitPath = systemdUnitPath();
+	const disableRes = runCapture("systemctl", [
+		"--user",
+		"disable",
+		"--now",
+		SYSTEMD_UNIT
+	], 1e4);
+	if (!disableRes.ok && !/not found|no such|not loaded/i.test(disableRes.stderr)) process.stderr.write(`    warning: systemctl disable during uninstall: ${disableRes.stderr || `exit ${disableRes.code ?? "unknown"}`}\n`);
+	if (existsSync(unitPath)) rmSync(unitPath);
+	const reloadRes = runCapture("systemctl", ["--user", "daemon-reload"], 5e3);
+	if (!reloadRes.ok) process.stderr.write(`    warning: systemctl daemon-reload during uninstall: ${reloadRes.stderr || `exit ${reloadRes.code ?? "unknown"}`}\n`);
+	return {
+		platform: "systemd",
+		label: SYSTEMD_UNIT,
+		unitPath,
+		logDir: LOG_DIR,
+		state: "not-installed"
+	};
+}
+/** Is background-service install supported on the current platform? */
+function isServiceSupported() {
+	return process.platform === "darwin" || process.platform === "linux";
+}
+/**
+* Install the background service for the current platform.
+*
+* @throws {Error} if the platform is not supported or the service manager fails.
+*/
+function installClientService() {
+	if (process.platform === "darwin") return installLaunchd();
+	if (process.platform === "linux") return installSystemd();
+	throw new Error(`Background service install is not supported on ${process.platform}. Run \`first-tree-hub client start\` manually to keep the computer online.`);
+}
+/** Report the current service state without modifying anything. */
+function getClientServiceStatus() {
+	if (process.platform === "darwin") {
+		const { state, detail } = launchdState();
+		return {
+			platform: "launchd",
+			label: LAUNCHD_LABEL,
+			unitPath: launchdPlistPath(),
+			logDir: LOG_DIR,
+			state,
+			detail
+		};
+	}
+	if (process.platform === "linux") {
+		const { state, detail } = systemdState();
+		return {
+			platform: "systemd",
+			label: SYSTEMD_UNIT,
+			unitPath: systemdUnitPath(),
+			logDir: LOG_DIR,
+			state,
+			detail
+		};
+	}
+	return {
+		platform: "unsupported",
+		label: "",
+		unitPath: "",
+		logDir: LOG_DIR,
+		state: "not-installed",
+		detail: `platform ${process.platform} not supported`
+	};
+}
+/** Uninstall the background service. No-op if not installed. */
+function uninstallClientService() {
+	if (process.platform === "darwin") return uninstallLaunchd();
+	if (process.platform === "linux") return uninstallSystemd();
+	return getClientServiceStatus();
+}
+//#endregion
+//#region src/core/migrate-home.ts
+/**
+* Run the one-shot legacy home migration at CLI startup and, if it succeeds,
+* re-register the background service so launchd/systemd pick up the new
+* `StandardOutPath` / `StandardErrorPath` / `ExecStart` log paths (those are
+* baked into the plist/unit file at install time — when we populate the new
+* home, those paths would otherwise still point at the old location).
+*
+* Copy-only semantics: the legacy `~/.first-tree-hub/` tree is preserved
+* as a safety net. The user can inspect/fall-back to it, and can delete it
+* manually once they've confirmed the new layout is healthy.
+*
+* Contract:
+*   - Synchronous and cheap when there's nothing to do (most runs — the
+*     steady state is "new dir populated", which short-circuits the copy).
+*   - Never throws — migration failures and service re-register failures
+*     both fall through to a stderr warning so the CLI command still runs.
+*   - Idempotent — safe to call on every CLI invocation.
+*   - Skips service re-register when we are already running AS the service
+*     (launchd/systemd invoke the CLI with `--no-interactive`), because the
+*     re-register would bootout our own process mid-execution.
+*/
+function runHomeMigration() {
+	const result = migrateLegacyHome({
+		newHome: DEFAULT_HOME_DIR$1,
+		envOverride: process.env.FIRST_TREE_HUB_HOME ?? null
+	});
+	if (!result.migrated) {
+		if (result.reason === "failed") process.stderr.write(`[first-tree-hub] WARNING: failed to auto-migrate legacy home ${result.from} → ${result.to}: ${result.error ?? "unknown error"}\n  Resolve manually: cp -R "${result.from}" "${result.to}"\n`);
+		return;
+	}
+	process.stderr.write(`[first-tree-hub] Copied client home to new layout: ${result.from} → ${result.to}\n  (Legacy directory preserved as a backup — delete it manually once you've verified the new location works.)\n`);
+	if (process.argv.includes("--no-interactive")) {
+		process.stderr.write("[first-tree-hub] Note: running as background service — skipped auto re-register to avoid self-termination.\n  Run `first-tree-hub client service install` from a terminal to refresh log paths.\n");
+		return;
+	}
+	const status = getClientServiceStatus();
+	if (status.platform === "unsupported" || status.state === "not-installed") return;
+	try {
+		installClientService();
+		process.stderr.write(`[first-tree-hub] Re-registered background service with new home paths.\n`);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		process.stderr.write(`[first-tree-hub] WARNING: home migration succeeded but re-registering the background service failed: ${msg}\n  Run \`first-tree-hub client service install\` to refresh log paths.\n`);
+	}
+}
+//#endregion
+//#region src/core/onboard.ts
+const STATE_FILE = join(DEFAULT_HOME_DIR$1, ".onboard-state.json");
+/** Save current onboard args to state file for resume. */
+function saveOnboardState(args) {
+	mkdirSync(DEFAULT_HOME_DIR$1, { recursive: true });
+	writeFileSync(STATE_FILE, JSON.stringify({ args }, null, 2));
+}
+/** Load saved onboard args from state file. */
+function loadOnboardState() {
+	try {
+		return JSON.parse(readFileSync(STATE_FILE, "utf-8")).args;
+	} catch {
+		return null;
+	}
+}
+async function onboardCheck(args) {
+	const items = [];
+	const creds = loadCredentials();
+	if (creds) items.push({
+		key: "connect",
+		label: "Signed in",
+		status: "ok",
+		value: creds.serverUrl
+	});
+	else items.push({
+		key: "connect",
+		label: "Signed in",
+		status: "missing_required",
+		hint: "Run `first-tree-hub client connect <server-url>` first"
+	});
+	try {
+		const serverUrl = resolveServerUrl(args.server);
+		items.push({
+			key: "server",
+			label: "Server URL",
+			status: "ok",
+			value: serverUrl
+		});
+		try {
+			const res = await fetch(`${serverUrl}/api/v1/health`);
+			items.push({
+				key: "server_reachable",
+				label: "Server reachable",
+				status: res.ok ? "ok" : "error",
+				value: res.ok ? "healthy" : `HTTP ${res.status}`
+			});
+		} catch {
+			items.push({
+				key: "server_reachable",
+				label: "Server reachable",
+				status: "error",
+				hint: "Cannot connect to server"
+			});
+		}
+	} catch {
+		items.push({
+			key: "server",
+			label: "Server URL",
+			status: "missing_required",
+			hint: "Provide via --server, FIRST_TREE_HUB_SERVER_URL, or config"
+		});
+	}
+	if (args.id) items.push({
+		key: "id",
+		label: "Agent ID",
+		status: "ok",
+		value: args.id
+	});
+	else items.push({
+		key: "id",
+		label: "Agent ID",
+		status: "missing_required",
+		hint: "Provide via --id"
+	});
+	if (args.type) items.push({
+		key: "type",
+		label: "Agent type",
+		status: "ok",
+		value: args.type
+	});
+	else items.push({
+		key: "type",
+		label: "Agent type",
+		status: "missing_required",
+		hint: "Provide via --type"
+	});
+	if (args.type && args.type !== "human") if (args.clientId) items.push({
+		key: "client",
+		label: "Target client",
+		status: "ok",
+		value: args.clientId
+	});
+	else items.push({
+		key: "client",
+		label: "Target client",
+		status: "ok",
+		value: "(unbound — claimed on first WS connect)"
+	});
+	return items;
+}
+function formatCheckReport(items) {
+	const lines = [];
+	for (const item of items) {
+		const icon = item.status === "ok" ? "✅" : item.status === "missing_required" ? "❌" : item.status === "error" ? "❌" : item.status === "warning" ? "⚠️" : "⬜";
+		const valueStr = item.value ? `  ${item.value}` : "";
+		const hintStr = item.hint ? `  (${item.hint})` : "";
+		lines.push(`  ${icon} ${item.label.padEnd(20)}${valueStr}${hintStr}`);
+	}
+	return lines.join("\n");
+}
+async function createAgentViaAdmin(serverUrl, accessToken, body) {
+	const res = await fetch(`${serverUrl}/api/v1/admin/agents`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(body),
+		signal: AbortSignal.timeout(1e4)
+	});
+	if (!res.ok) {
+		const errBody = await res.json().catch(() => ({}));
+		throw new Error(errBody.error ?? `Failed to create agent (HTTP ${res.status})`);
+	}
+	return await res.json();
+}
+async function onboardCreate(args) {
+	const serverUrl = resolveServerUrl(args.server).replace(/\/+$/, "");
+	const accessToken = await ensureFreshAccessToken();
+	const metadata = {};
 	if (args.role) metadata.role = args.role;
 	if (args.domains) metadata.domains = args.domains.split(",").map((d) => d.trim());
 	process.stderr.write(`Creating agent "${args.id}"...\n`);
@@ -4647,174 +5328,2880 @@ async function onboardCreate(args) {
 		metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
 		clientId: args.type === "human" ? void 0 : args.clientId
 	});
-	process.stderr.write(`Agent "${args.id}" created (uuid ${primary.uuid}).\n`);
-	if (args.type !== "human") saveAgentConfig(args.id, primary.uuid, "claude-code");
-	let assistantUuid = null;
-	if (args.assistant) {
-		process.stderr.write(`Creating assistant "${args.assistant}"...\n`);
+	process.stderr.write(`Agent "${args.id}" created (uuid ${primary.uuid}).\n`);
+	if (args.type !== "human") saveAgentConfig(args.id, primary.uuid, "claude-code");
+	let assistantUuid = null;
+	if (args.assistant) {
+		process.stderr.write(`Creating assistant "${args.assistant}"...\n`);
+		try {
+			const assistant = await createAgentViaAdmin(serverUrl, accessToken, {
+				name: args.assistant,
+				type: "personal_assistant",
+				displayName: args.assistant,
+				metadata: {
+					role: `Personal Assistant to ${args.id}`,
+					domains: ["message triage", "task coordination"]
+				},
+				clientId: args.clientId
+			});
+			assistantUuid = assistant.uuid;
+			saveAgentConfig(args.assistant, assistant.uuid, "claude-code");
+			process.stderr.write(`Assistant "${args.assistant}" ready.\n`);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`Warning: Failed to create assistant "${args.assistant}": ${msg}\n`);
+		}
+	}
+	const runtimeAgent = args.type === "human" ? args.assistant : args.id;
+	if (args.feishuBotAppId && args.feishuBotAppSecret) {
+		const { bindFeishuBot } = await import("./feishu-GlaczcVf.mjs").then((n) => n.r);
+		const targetAgentUuid = args.type === "human" ? assistantUuid : primary.uuid;
+		if (!targetAgentUuid) process.stderr.write(`Warning: Cannot bind Feishu bot — no runtime agent available for "${args.id}".\n`);
+		else {
+			process.stderr.write("Binding Feishu bot...\n");
+			await bindFeishuBot(serverUrl, accessToken, targetAgentUuid, args.feishuBotAppId, args.feishuBotAppSecret);
+			process.stderr.write("Feishu bot bound.\n");
+		}
+	}
+	setConfigValue(join(DEFAULT_CONFIG_DIR, "client.yaml"), "server.url", serverUrl);
+	try {
+		const { unlinkSync } = await import("node:fs");
+		unlinkSync(STATE_FILE);
+	} catch {}
+	const typeLabel = args.type === "human" ? "Human" : args.type === "autonomous_agent" ? "Agent" : "Assistant";
+	process.stderr.write("\n✅ Onboard complete!\n\n");
+	process.stderr.write(`  ${typeLabel}:${" ".repeat(Math.max(1, 10 - typeLabel.length))}${args.id}\n`);
+	if (args.assistant) process.stderr.write(`  Assistant: ${args.assistant}\n`);
+	if (runtimeAgent) process.stderr.write(`  Config:    ${DEFAULT_HOME_DIR$1}/config/agents/${runtimeAgent}/agent.yaml\n`);
+	if (args.feishuBotAppId) process.stderr.write(`  Feishu:    bot bound (${args.feishuBotAppId})\n`);
+	if (args.type === "human") {
+		process.stderr.write("\n  Next step — bind your Feishu account:\n");
+		process.stderr.write(`    Send this message to the bot in Feishu:  /bind ${args.id}\n`);
+		if (!args.feishuBotAppId) process.stderr.write("    (requires a Feishu bot to be configured in the system)\n");
+	}
+	if (runtimeAgent) {
+		process.stderr.write("\n  Start the agent:\n");
+		process.stderr.write("    first-tree-hub client start\n");
+	}
+	process.stderr.write("\n");
+}
+//#endregion
+//#region src/core/prompt.ts
+/**
+* Check if interactive mode is available.
+* Returns false if --no-interactive flag is set or stdin is not a TTY.
+*/
+function isInteractive(noInteractiveFlag) {
+	if (noInteractiveFlag) return false;
+	return process.stdin.isTTY === true;
+}
+/**
+* Schema-driven interactive setup.
+* Scans the config schema for fields with `prompt` that are missing.
+*
+* In interactive mode: prompts the user and writes results to YAML.
+* In non-interactive mode: fails with a clear error listing missing fields.
+*/
+async function promptMissingFields(options) {
+	const missing = collectMissingPrompts({
+		schema: options.schema,
+		role: options.role,
+		configDir: options.configDir,
+		cliArgs: options.cliArgs
+	});
+	if (missing.length === 0) return {};
+	if (!isInteractive(options.noInteractive)) {
+		const lines = missing.map((m) => {
+			const envHint = findEnvVar(options.schema, m.dotPath);
+			const envStr = envHint ? `  (env: ${envHint})` : "";
+			return `  ${m.dotPath}${envStr}`;
+		});
+		throw new Error(`Missing required configuration:\n${lines.join("\n")}\n\nProvide values via environment variables, config file (${DEFAULT_HOME_DIR$1}/server.yaml),\nor run without --no-interactive to use the interactive setup wizard.`);
+	}
+	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${options.role}.yaml`);
+	const results = {};
+	for (const { dotPath, prompt } of missing) {
+		const value = await askPrompt(dotPath, prompt);
+		if (value !== void 0) {
+			setConfigValue(configPath, dotPath, value);
+			setNestedByDot(results, dotPath, value);
+		}
+	}
+	return results;
+}
+/**
+* Interactive add agent — simple two-field prompt.
+*/
+async function promptAddAgent() {
+	return {
+		name: await input({
+			message: "Local alias:",
+			validate: (v) => /^[a-z0-9][a-z0-9-]*$/.test(v) ? true : "Lowercase alphanumeric and hyphens only"
+		}),
+		agentId: await input({
+			message: "Agent UUID on the Hub:",
+			validate: (v) => v.length > 0 ? true : "Agent UUID is required"
+		})
+	};
+}
+async function askPrompt(dotPath, prompt) {
+	const type = prompt.type ?? "input";
+	if (type === "select" && prompt.choices) {
+		const value = await select({
+			message: prompt.message,
+			choices: prompt.choices.map((c) => ({
+				name: c.name,
+				value: c.value
+			}))
+		});
+		if (value === "__auto__") return void 0;
+		if (value === "__input__") return input({
+			message: `${dotPath}:`,
+			validate: (v) => v.length > 0 ? true : "Value is required"
+		});
+		return value;
+	}
+	if (type === "password") return password({ message: prompt.message });
+	return input({
+		message: prompt.message,
+		default: prompt.default
+	});
+}
+/** Walk schema to find the env var name for a given dot path. */
+function findEnvVar(schema, dotPath) {
+	const parts = dotPath.split(".");
+	let current = schema;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return void 0;
+		const obj = current;
+		if (obj._tag === "optional") current = obj.shape[part];
+		else current = obj[part];
+	}
+	if (typeof current === "object" && current !== null && "_tag" in current) {
+		const field = current;
+		if (field._tag === "field") return field.options?.env;
+	}
+}
+function setNestedByDot(obj, dotPath, value) {
+	const parts = dotPath.split(".");
+	let current = obj;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const key = parts[i];
+		if (key === void 0) continue;
+		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) current[key] = {};
+		current = current[key];
+	}
+	const lastKey = parts.at(-1);
+	if (lastKey !== void 0) current[lastKey] = value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/deps/streamsearch/sbmh.js
+var require_sbmh = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Copyright Brian White. All rights reserved.
+	*
+	* @see https://github.com/mscdex/streamsearch
+	*
+	* Permission is hereby granted, free of charge, to any person obtaining a copy
+	* of this software and associated documentation files (the "Software"), to
+	* deal in the Software without restriction, including without limitation the
+	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+	* sell copies of the Software, and to permit persons to whom the Software is
+	* furnished to do so, subject to the following conditions:
+	*
+	* The above copyright notice and this permission notice shall be included in
+	* all copies or substantial portions of the Software.
+	*
+	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+	* IN THE SOFTWARE.
+	*
+	* Based heavily on the Streaming Boyer-Moore-Horspool C++ implementation
+	* by Hongli Lai at: https://github.com/FooBarWidget/boyer-moore-horspool
+	*/
+	const { EventEmitter: EventEmitter$2 } = __require("node:events");
+	const { inherits: inherits$5 } = __require("node:util");
+	function SBMH(needle) {
+		if (typeof needle === "string") needle = Buffer.from(needle);
+		if (!Buffer.isBuffer(needle)) throw new TypeError("The needle has to be a String or a Buffer.");
+		const needleLength = needle.length;
+		const needleLastCharIndex = needleLength - 1;
+		if (needleLength === 0) throw new Error("The needle cannot be an empty String/Buffer.");
+		if (needleLength > 256) throw new Error("The needle cannot have a length bigger than 256.");
+		this.maxMatches = Infinity;
+		this.matches = 0;
+		this._occ = new Uint8Array(256).fill(needleLength);
+		this._lookbehind_size = 0;
+		this._needle = needle;
+		this._bufpos = 0;
+		this._lookbehind = Buffer.alloc(needleLastCharIndex);
+		for (var i = 0; i < needleLastCharIndex; ++i) this._occ[needle[i]] = needleLastCharIndex - i;
+	}
+	inherits$5(SBMH, EventEmitter$2);
+	SBMH.prototype.reset = function() {
+		this._lookbehind_size = 0;
+		this.matches = 0;
+		this._bufpos = 0;
+	};
+	SBMH.prototype.push = function(chunk, pos) {
+		if (!Buffer.isBuffer(chunk)) chunk = Buffer.from(chunk, "binary");
+		const chlen = chunk.length;
+		this._bufpos = pos || 0;
+		let r;
+		while (r !== chlen && this.matches < this.maxMatches) r = this._sbmh_feed(chunk);
+		return r;
+	};
+	SBMH.prototype._sbmh_feed = function(data) {
+		const len = data.length;
+		const needle = this._needle;
+		const needleLength = needle.length;
+		const needleLastCharIndex = needleLength - 1;
+		const needleLastChar = needle[needleLastCharIndex];
+		let pos = -this._lookbehind_size;
+		let ch;
+		if (pos < 0) {
+			while (pos < 0 && pos <= len - needleLength) {
+				ch = data[pos + needleLastCharIndex];
+				if (ch === needleLastChar && this._sbmh_memcmp(data, pos, needleLastCharIndex)) {
+					this._lookbehind_size = 0;
+					++this.matches;
+					this.emit("info", true);
+					return this._bufpos = pos + needleLength;
+				}
+				pos += this._occ[ch];
+			}
+			while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) ++pos;
+			if (pos >= 0) {
+				this.emit("info", false, this._lookbehind, 0, this._lookbehind_size);
+				this._lookbehind_size = 0;
+			} else {
+				const bytesToCutOff = this._lookbehind_size + pos;
+				if (bytesToCutOff > 0) this.emit("info", false, this._lookbehind, 0, bytesToCutOff);
+				this._lookbehind_size -= bytesToCutOff;
+				this._lookbehind.copy(this._lookbehind, 0, bytesToCutOff, this._lookbehind_size);
+				data.copy(this._lookbehind, this._lookbehind_size);
+				this._lookbehind_size += len;
+				this._bufpos = len;
+				return len;
+			}
+		}
+		pos = data.indexOf(needle, pos + this._bufpos);
+		if (pos !== -1) {
+			++this.matches;
+			if (pos === 0) this.emit("info", true);
+			else this.emit("info", true, data, this._bufpos, pos);
+			return this._bufpos = pos + needleLength;
+		}
+		pos = len - needleLastCharIndex;
+		if (pos < 0) pos = 0;
+		while (pos !== len && (data[pos] !== needle[0] || Buffer.compare(data.subarray(pos + 1, len), needle.subarray(1, len - pos)) !== 0)) ++pos;
+		if (pos !== len) {
+			data.copy(this._lookbehind, 0, pos, len);
+			this._lookbehind_size = len - pos;
+		}
+		if (pos !== 0) this.emit("info", false, data, this._bufpos, pos);
+		this._bufpos = len;
+		return len;
+	};
+	SBMH.prototype._sbmh_lookup_char = function(data, pos) {
+		return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos];
+	};
+	SBMH.prototype._sbmh_memcmp = function(data, pos, len) {
+		for (var i = 0; i < len; ++i) if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) return false;
+		return true;
+	};
+	module.exports = SBMH;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js
+var require_PartStream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const inherits$4 = __require("node:util").inherits;
+	const ReadableStream = __require("node:stream").Readable;
+	function PartStream(opts) {
+		ReadableStream.call(this, opts);
+	}
+	inherits$4(PartStream, ReadableStream);
+	PartStream.prototype._read = function(n) {};
+	module.exports = PartStream;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/utils/getLimit.js
+var require_getLimit = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function getLimit(limits, name, defaultLimit) {
+		if (!limits || limits[name] === void 0 || limits[name] === null) return defaultLimit;
+		if (typeof limits[name] !== "number" || isNaN(limits[name])) throw new TypeError("Limit " + name + " is not a valid number");
+		return limits[name];
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js
+var require_HeaderParser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const EventEmitter$1 = __require("node:events").EventEmitter;
+	const inherits$3 = __require("node:util").inherits;
+	const getLimit = require_getLimit();
+	const StreamSearch = require_sbmh();
+	const B_DCRLF = Buffer.from("\r\n\r\n");
+	const RE_CRLF = /\r\n/g;
+	const RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/;
+	function HeaderParser(cfg) {
+		EventEmitter$1.call(this);
+		cfg = cfg || {};
+		const self = this;
+		this.nread = 0;
+		this.maxed = false;
+		this.npairs = 0;
+		this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3);
+		this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024);
+		this.buffer = "";
+		this.header = {};
+		this.finished = false;
+		this.ss = new StreamSearch(B_DCRLF);
+		this.ss.on("info", function(isMatch, data, start, end) {
+			if (data && !self.maxed) {
+				if (self.nread + end - start >= self.maxHeaderSize) {
+					end = self.maxHeaderSize - self.nread + start;
+					self.nread = self.maxHeaderSize;
+					self.maxed = true;
+				} else self.nread += end - start;
+				self.buffer += data.toString("binary", start, end);
+			}
+			if (isMatch) self._finish();
+		});
+	}
+	inherits$3(HeaderParser, EventEmitter$1);
+	HeaderParser.prototype.push = function(data) {
+		const r = this.ss.push(data);
+		if (this.finished) return r;
+	};
+	HeaderParser.prototype.reset = function() {
+		this.finished = false;
+		this.buffer = "";
+		this.header = {};
+		this.ss.reset();
+	};
+	HeaderParser.prototype._finish = function() {
+		if (this.buffer) this._parseHeader();
+		this.ss.matches = this.ss.maxMatches;
+		const header = this.header;
+		this.header = {};
+		this.buffer = "";
+		this.finished = true;
+		this.nread = this.npairs = 0;
+		this.maxed = false;
+		this.emit("header", header);
+	};
+	HeaderParser.prototype._parseHeader = function() {
+		if (this.npairs === this.maxHeaderPairs) return;
+		const lines = this.buffer.split(RE_CRLF);
+		const len = lines.length;
+		let m, h;
+		for (var i = 0; i < len; ++i) {
+			if (lines[i].length === 0) continue;
+			if (lines[i][0] === "	" || lines[i][0] === " ") {
+				if (h) {
+					this.header[h][this.header[h].length - 1] += lines[i];
+					continue;
+				}
+			}
+			const posColon = lines[i].indexOf(":");
+			if (posColon === -1 || posColon === 0) return;
+			m = RE_HDR.exec(lines[i]);
+			h = m[1].toLowerCase();
+			this.header[h] = this.header[h] || [];
+			this.header[h].push(m[2] || "");
+			if (++this.npairs === this.maxHeaderPairs) break;
+		}
+	};
+	module.exports = HeaderParser;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js
+var require_Dicer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const WritableStream$1 = __require("node:stream").Writable;
+	const inherits$2 = __require("node:util").inherits;
+	const StreamSearch = require_sbmh();
+	const PartStream = require_PartStream();
+	const HeaderParser = require_HeaderParser();
+	const DASH = 45;
+	const B_ONEDASH = Buffer.from("-");
+	const B_CRLF = Buffer.from("\r\n");
+	const EMPTY_FN = function() {};
+	function Dicer(cfg) {
+		if (!(this instanceof Dicer)) return new Dicer(cfg);
+		WritableStream$1.call(this, cfg);
+		if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") throw new TypeError("Boundary required");
+		if (typeof cfg.boundary === "string") this.setBoundary(cfg.boundary);
+		else this._bparser = void 0;
+		this._headerFirst = cfg.headerFirst;
+		this._dashes = 0;
+		this._parts = 0;
+		this._finished = false;
+		this._realFinish = false;
+		this._isPreamble = true;
+		this._justMatched = false;
+		this._firstWrite = true;
+		this._inHeader = true;
+		this._part = void 0;
+		this._cb = void 0;
+		this._ignoreData = false;
+		this._partOpts = { highWaterMark: cfg.partHwm };
+		this._pause = false;
+		const self = this;
+		this._hparser = new HeaderParser(cfg);
+		this._hparser.on("header", function(header) {
+			self._inHeader = false;
+			self._part.emit("header", header);
+		});
+	}
+	inherits$2(Dicer, WritableStream$1);
+	Dicer.prototype.emit = function(ev) {
+		if (ev === "finish" && !this._realFinish) {
+			if (!this._finished) {
+				const self = this;
+				process.nextTick(function() {
+					self.emit("error", /* @__PURE__ */ new Error("Unexpected end of multipart data"));
+					if (self._part && !self._ignoreData) {
+						const type = self._isPreamble ? "Preamble" : "Part";
+						self._part.emit("error", /* @__PURE__ */ new Error(type + " terminated early due to unexpected end of multipart data"));
+						self._part.push(null);
+						process.nextTick(function() {
+							self._realFinish = true;
+							self.emit("finish");
+							self._realFinish = false;
+						});
+						return;
+					}
+					self._realFinish = true;
+					self.emit("finish");
+					self._realFinish = false;
+				});
+			}
+		} else WritableStream$1.prototype.emit.apply(this, arguments);
+	};
+	Dicer.prototype._write = function(data, encoding, cb) {
+		if (!this._hparser && !this._bparser) return cb();
+		if (this._headerFirst && this._isPreamble) {
+			if (!this._part) {
+				this._part = new PartStream(this._partOpts);
+				if (this.listenerCount("preamble") !== 0) this.emit("preamble", this._part);
+				else this._ignore();
+			}
+			const r = this._hparser.push(data);
+			if (!this._inHeader && r !== void 0 && r < data.length) data = data.slice(r);
+			else return cb();
+		}
+		if (this._firstWrite) {
+			this._bparser.push(B_CRLF);
+			this._firstWrite = false;
+		}
+		this._bparser.push(data);
+		if (this._pause) this._cb = cb;
+		else cb();
+	};
+	Dicer.prototype.reset = function() {
+		this._part = void 0;
+		this._bparser = void 0;
+		this._hparser = void 0;
+	};
+	Dicer.prototype.setBoundary = function(boundary) {
+		const self = this;
+		this._bparser = new StreamSearch("\r\n--" + boundary);
+		this._bparser.on("info", function(isMatch, data, start, end) {
+			self._oninfo(isMatch, data, start, end);
+		});
+	};
+	Dicer.prototype._ignore = function() {
+		if (this._part && !this._ignoreData) {
+			this._ignoreData = true;
+			this._part.on("error", EMPTY_FN);
+			this._part.resume();
+		}
+	};
+	Dicer.prototype._oninfo = function(isMatch, data, start, end) {
+		let buf;
+		const self = this;
+		let i = 0;
+		let r;
+		let shouldWriteMore = true;
+		if (!this._part && this._justMatched && data) {
+			while (this._dashes < 2 && start + i < end) if (data[start + i] === DASH) {
+				++i;
+				++this._dashes;
+			} else {
+				if (this._dashes) buf = B_ONEDASH;
+				this._dashes = 0;
+				break;
+			}
+			if (this._dashes === 2) {
+				if (start + i < end && this.listenerCount("trailer") !== 0) this.emit("trailer", data.slice(start + i, end));
+				this.reset();
+				this._finished = true;
+				if (self._parts === 0) {
+					self._realFinish = true;
+					self.emit("finish");
+					self._realFinish = false;
+				}
+			}
+			if (this._dashes) return;
+		}
+		if (this._justMatched) this._justMatched = false;
+		if (!this._part) {
+			this._part = new PartStream(this._partOpts);
+			this._part._read = function(n) {
+				self._unpause();
+			};
+			if (this._isPreamble && this.listenerCount("preamble") !== 0) this.emit("preamble", this._part);
+			else if (this._isPreamble !== true && this.listenerCount("part") !== 0) this.emit("part", this._part);
+			else this._ignore();
+			if (!this._isPreamble) this._inHeader = true;
+		}
+		if (data && start < end && !this._ignoreData) {
+			if (this._isPreamble || !this._inHeader) {
+				if (buf) shouldWriteMore = this._part.push(buf);
+				shouldWriteMore = this._part.push(data.slice(start, end));
+				if (!shouldWriteMore) this._pause = true;
+			} else if (!this._isPreamble && this._inHeader) {
+				if (buf) this._hparser.push(buf);
+				r = this._hparser.push(data.slice(start, end));
+				if (!this._inHeader && r !== void 0 && r < end) this._oninfo(false, data, start + r, end);
+			}
+		}
+		if (isMatch) {
+			this._hparser.reset();
+			if (this._isPreamble) this._isPreamble = false;
+			else if (start !== end) {
+				++this._parts;
+				this._part.on("end", function() {
+					if (--self._parts === 0) if (self._finished) {
+						self._realFinish = true;
+						self.emit("finish");
+						self._realFinish = false;
+					} else self._unpause();
+				});
+			}
+			this._part.push(null);
+			this._part = void 0;
+			this._ignoreData = false;
+			this._justMatched = true;
+			this._dashes = 0;
+		}
+	};
+	Dicer.prototype._unpause = function() {
+		if (!this._pause) return;
+		this._pause = false;
+		if (this._cb) {
+			const cb = this._cb;
+			this._cb = void 0;
+			cb();
+		}
+	};
+	module.exports = Dicer;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/utils/decodeText.js
+var require_decodeText = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const utf8Decoder = new TextDecoder("utf-8");
+	const textDecoders = new Map([["utf-8", utf8Decoder], ["utf8", utf8Decoder]]);
+	function getDecoder(charset) {
+		let lc;
+		while (true) switch (charset) {
+			case "utf-8":
+			case "utf8": return decoders.utf8;
+			case "latin1":
+			case "ascii":
+			case "us-ascii":
+			case "iso-8859-1":
+			case "iso8859-1":
+			case "iso88591":
+			case "iso_8859-1":
+			case "windows-1252":
+			case "iso_8859-1:1987":
+			case "cp1252":
+			case "x-cp1252": return decoders.latin1;
+			case "utf16le":
+			case "utf-16le":
+			case "ucs2":
+			case "ucs-2": return decoders.utf16le;
+			case "base64": return decoders.base64;
+			default:
+				if (lc === void 0) {
+					lc = true;
+					charset = charset.toLowerCase();
+					continue;
+				}
+				return decoders.other.bind(charset);
+		}
+	}
+	const decoders = {
+		utf8: (data, sourceEncoding) => {
+			if (data.length === 0) return "";
+			if (typeof data === "string") data = Buffer.from(data, sourceEncoding);
+			return data.utf8Slice(0, data.length);
+		},
+		latin1: (data, sourceEncoding) => {
+			if (data.length === 0) return "";
+			if (typeof data === "string") return data;
+			return data.latin1Slice(0, data.length);
+		},
+		utf16le: (data, sourceEncoding) => {
+			if (data.length === 0) return "";
+			if (typeof data === "string") data = Buffer.from(data, sourceEncoding);
+			return data.ucs2Slice(0, data.length);
+		},
+		base64: (data, sourceEncoding) => {
+			if (data.length === 0) return "";
+			if (typeof data === "string") data = Buffer.from(data, sourceEncoding);
+			return data.base64Slice(0, data.length);
+		},
+		other: (data, sourceEncoding) => {
+			if (data.length === 0) return "";
+			if (typeof data === "string") data = Buffer.from(data, sourceEncoding);
+			if (textDecoders.has(exports.toString())) try {
+				return textDecoders.get(exports).decode(data);
+			} catch {}
+			return typeof data === "string" ? data : data.toString();
+		}
+	};
+	function decodeText(text, sourceEncoding, destEncoding) {
+		if (text) return getDecoder(destEncoding)(text, sourceEncoding);
+		return text;
+	}
+	module.exports = decodeText;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/utils/parseParams.js
+var require_parseParams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const decodeText = require_decodeText();
+	const RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g;
+	const EncodedLookup = {
+		"%00": "\0",
+		"%01": "
",
+		"%02": "",
+		"%03": "",
+		"%04": "",
+		"%05": "",
+		"%06": "",
+		"%07": "\x07",
+		"%08": "\b",
+		"%09": "	",
+		"%0a": "\n",
+		"%0A": "\n",
+		"%0b": "\v",
+		"%0B": "\v",
+		"%0c": "\f",
+		"%0C": "\f",
+		"%0d": "\r",
+		"%0D": "\r",
+		"%0e": "",
+		"%0E": "",
+		"%0f": "",
+		"%0F": "",
+		"%10": "",
+		"%11": "",
+		"%12": "",
+		"%13": "",
+		"%14": "",
+		"%15": "",
+		"%16": "",
+		"%17": "",
+		"%18": "",
+		"%19": "",
+		"%1a": "",
+		"%1A": "",
+		"%1b": "\x1B",
+		"%1B": "\x1B",
+		"%1c": "",
+		"%1C": "",
+		"%1d": "",
+		"%1D": "",
+		"%1e": "",
+		"%1E": "",
+		"%1f": "",
+		"%1F": "",
+		"%20": " ",
+		"%21": "!",
+		"%22": "\"",
+		"%23": "#",
+		"%24": "$",
+		"%25": "%",
+		"%26": "&",
+		"%27": "'",
+		"%28": "(",
+		"%29": ")",
+		"%2a": "*",
+		"%2A": "*",
+		"%2b": "+",
+		"%2B": "+",
+		"%2c": ",",
+		"%2C": ",",
+		"%2d": "-",
+		"%2D": "-",
+		"%2e": ".",
+		"%2E": ".",
+		"%2f": "/",
+		"%2F": "/",
+		"%30": "0",
+		"%31": "1",
+		"%32": "2",
+		"%33": "3",
+		"%34": "4",
+		"%35": "5",
+		"%36": "6",
+		"%37": "7",
+		"%38": "8",
+		"%39": "9",
+		"%3a": ":",
+		"%3A": ":",
+		"%3b": ";",
+		"%3B": ";",
+		"%3c": "<",
+		"%3C": "<",
+		"%3d": "=",
+		"%3D": "=",
+		"%3e": ">",
+		"%3E": ">",
+		"%3f": "?",
+		"%3F": "?",
+		"%40": "@",
+		"%41": "A",
+		"%42": "B",
+		"%43": "C",
+		"%44": "D",
+		"%45": "E",
+		"%46": "F",
+		"%47": "G",
+		"%48": "H",
+		"%49": "I",
+		"%4a": "J",
+		"%4A": "J",
+		"%4b": "K",
+		"%4B": "K",
+		"%4c": "L",
+		"%4C": "L",
+		"%4d": "M",
+		"%4D": "M",
+		"%4e": "N",
+		"%4E": "N",
+		"%4f": "O",
+		"%4F": "O",
+		"%50": "P",
+		"%51": "Q",
+		"%52": "R",
+		"%53": "S",
+		"%54": "T",
+		"%55": "U",
+		"%56": "V",
+		"%57": "W",
+		"%58": "X",
+		"%59": "Y",
+		"%5a": "Z",
+		"%5A": "Z",
+		"%5b": "[",
+		"%5B": "[",
+		"%5c": "\\",
+		"%5C": "\\",
+		"%5d": "]",
+		"%5D": "]",
+		"%5e": "^",
+		"%5E": "^",
+		"%5f": "_",
+		"%5F": "_",
+		"%60": "`",
+		"%61": "a",
+		"%62": "b",
+		"%63": "c",
+		"%64": "d",
+		"%65": "e",
+		"%66": "f",
+		"%67": "g",
+		"%68": "h",
+		"%69": "i",
+		"%6a": "j",
+		"%6A": "j",
+		"%6b": "k",
+		"%6B": "k",
+		"%6c": "l",
+		"%6C": "l",
+		"%6d": "m",
+		"%6D": "m",
+		"%6e": "n",
+		"%6E": "n",
+		"%6f": "o",
+		"%6F": "o",
+		"%70": "p",
+		"%71": "q",
+		"%72": "r",
+		"%73": "s",
+		"%74": "t",
+		"%75": "u",
+		"%76": "v",
+		"%77": "w",
+		"%78": "x",
+		"%79": "y",
+		"%7a": "z",
+		"%7A": "z",
+		"%7b": "{",
+		"%7B": "{",
+		"%7c": "|",
+		"%7C": "|",
+		"%7d": "}",
+		"%7D": "}",
+		"%7e": "~",
+		"%7E": "~",
+		"%7f": "",
+		"%7F": "",
+		"%80": "€",
+		"%81": "",
+		"%82": "‚",
+		"%83": "ƒ",
+		"%84": "„",
+		"%85": "…",
+		"%86": "†",
+		"%87": "‡",
+		"%88": "ˆ",
+		"%89": "‰",
+		"%8a": "Š",
+		"%8A": "Š",
+		"%8b": "‹",
+		"%8B": "‹",
+		"%8c": "Œ",
+		"%8C": "Œ",
+		"%8d": "",
+		"%8D": "",
+		"%8e": "Ž",
+		"%8E": "Ž",
+		"%8f": "",
+		"%8F": "",
+		"%90": "",
+		"%91": "‘",
+		"%92": "’",
+		"%93": "“",
+		"%94": "”",
+		"%95": "•",
+		"%96": "–",
+		"%97": "—",
+		"%98": "˜",
+		"%99": "™",
+		"%9a": "š",
+		"%9A": "š",
+		"%9b": "›",
+		"%9B": "›",
+		"%9c": "œ",
+		"%9C": "œ",
+		"%9d": "",
+		"%9D": "",
+		"%9e": "ž",
+		"%9E": "ž",
+		"%9f": "Ÿ",
+		"%9F": "Ÿ",
+		"%a0": "\xA0",
+		"%A0": "\xA0",
+		"%a1": "¡",
+		"%A1": "¡",
+		"%a2": "¢",
+		"%A2": "¢",
+		"%a3": "£",
+		"%A3": "£",
+		"%a4": "¤",
+		"%A4": "¤",
+		"%a5": "¥",
+		"%A5": "¥",
+		"%a6": "¦",
+		"%A6": "¦",
+		"%a7": "§",
+		"%A7": "§",
+		"%a8": "¨",
+		"%A8": "¨",
+		"%a9": "©",
+		"%A9": "©",
+		"%aa": "ª",
+		"%Aa": "ª",
+		"%aA": "ª",
+		"%AA": "ª",
+		"%ab": "«",
+		"%Ab": "«",
+		"%aB": "«",
+		"%AB": "«",
+		"%ac": "¬",
+		"%Ac": "¬",
+		"%aC": "¬",
+		"%AC": "¬",
+		"%ad": "­",
+		"%Ad": "­",
+		"%aD": "­",
+		"%AD": "­",
+		"%ae": "®",
+		"%Ae": "®",
+		"%aE": "®",
+		"%AE": "®",
+		"%af": "¯",
+		"%Af": "¯",
+		"%aF": "¯",
+		"%AF": "¯",
+		"%b0": "°",
+		"%B0": "°",
+		"%b1": "±",
+		"%B1": "±",
+		"%b2": "²",
+		"%B2": "²",
+		"%b3": "³",
+		"%B3": "³",
+		"%b4": "´",
+		"%B4": "´",
+		"%b5": "µ",
+		"%B5": "µ",
+		"%b6": "¶",
+		"%B6": "¶",
+		"%b7": "·",
+		"%B7": "·",
+		"%b8": "¸",
+		"%B8": "¸",
+		"%b9": "¹",
+		"%B9": "¹",
+		"%ba": "º",
+		"%Ba": "º",
+		"%bA": "º",
+		"%BA": "º",
+		"%bb": "»",
+		"%Bb": "»",
+		"%bB": "»",
+		"%BB": "»",
+		"%bc": "¼",
+		"%Bc": "¼",
+		"%bC": "¼",
+		"%BC": "¼",
+		"%bd": "½",
+		"%Bd": "½",
+		"%bD": "½",
+		"%BD": "½",
+		"%be": "¾",
+		"%Be": "¾",
+		"%bE": "¾",
+		"%BE": "¾",
+		"%bf": "¿",
+		"%Bf": "¿",
+		"%bF": "¿",
+		"%BF": "¿",
+		"%c0": "À",
+		"%C0": "À",
+		"%c1": "Á",
+		"%C1": "Á",
+		"%c2": "Â",
+		"%C2": "Â",
+		"%c3": "Ã",
+		"%C3": "Ã",
+		"%c4": "Ä",
+		"%C4": "Ä",
+		"%c5": "Å",
+		"%C5": "Å",
+		"%c6": "Æ",
+		"%C6": "Æ",
+		"%c7": "Ç",
+		"%C7": "Ç",
+		"%c8": "È",
+		"%C8": "È",
+		"%c9": "É",
+		"%C9": "É",
+		"%ca": "Ê",
+		"%Ca": "Ê",
+		"%cA": "Ê",
+		"%CA": "Ê",
+		"%cb": "Ë",
+		"%Cb": "Ë",
+		"%cB": "Ë",
+		"%CB": "Ë",
+		"%cc": "Ì",
+		"%Cc": "Ì",
+		"%cC": "Ì",
+		"%CC": "Ì",
+		"%cd": "Í",
+		"%Cd": "Í",
+		"%cD": "Í",
+		"%CD": "Í",
+		"%ce": "Î",
+		"%Ce": "Î",
+		"%cE": "Î",
+		"%CE": "Î",
+		"%cf": "Ï",
+		"%Cf": "Ï",
+		"%cF": "Ï",
+		"%CF": "Ï",
+		"%d0": "Ð",
+		"%D0": "Ð",
+		"%d1": "Ñ",
+		"%D1": "Ñ",
+		"%d2": "Ò",
+		"%D2": "Ò",
+		"%d3": "Ó",
+		"%D3": "Ó",
+		"%d4": "Ô",
+		"%D4": "Ô",
+		"%d5": "Õ",
+		"%D5": "Õ",
+		"%d6": "Ö",
+		"%D6": "Ö",
+		"%d7": "×",
+		"%D7": "×",
+		"%d8": "Ø",
+		"%D8": "Ø",
+		"%d9": "Ù",
+		"%D9": "Ù",
+		"%da": "Ú",
+		"%Da": "Ú",
+		"%dA": "Ú",
+		"%DA": "Ú",
+		"%db": "Û",
+		"%Db": "Û",
+		"%dB": "Û",
+		"%DB": "Û",
+		"%dc": "Ü",
+		"%Dc": "Ü",
+		"%dC": "Ü",
+		"%DC": "Ü",
+		"%dd": "Ý",
+		"%Dd": "Ý",
+		"%dD": "Ý",
+		"%DD": "Ý",
+		"%de": "Þ",
+		"%De": "Þ",
+		"%dE": "Þ",
+		"%DE": "Þ",
+		"%df": "ß",
+		"%Df": "ß",
+		"%dF": "ß",
+		"%DF": "ß",
+		"%e0": "à",
+		"%E0": "à",
+		"%e1": "á",
+		"%E1": "á",
+		"%e2": "â",
+		"%E2": "â",
+		"%e3": "ã",
+		"%E3": "ã",
+		"%e4": "ä",
+		"%E4": "ä",
+		"%e5": "å",
+		"%E5": "å",
+		"%e6": "æ",
+		"%E6": "æ",
+		"%e7": "ç",
+		"%E7": "ç",
+		"%e8": "è",
+		"%E8": "è",
+		"%e9": "é",
+		"%E9": "é",
+		"%ea": "ê",
+		"%Ea": "ê",
+		"%eA": "ê",
+		"%EA": "ê",
+		"%eb": "ë",
+		"%Eb": "ë",
+		"%eB": "ë",
+		"%EB": "ë",
+		"%ec": "ì",
+		"%Ec": "ì",
+		"%eC": "ì",
+		"%EC": "ì",
+		"%ed": "í",
+		"%Ed": "í",
+		"%eD": "í",
+		"%ED": "í",
+		"%ee": "î",
+		"%Ee": "î",
+		"%eE": "î",
+		"%EE": "î",
+		"%ef": "ï",
+		"%Ef": "ï",
+		"%eF": "ï",
+		"%EF": "ï",
+		"%f0": "ð",
+		"%F0": "ð",
+		"%f1": "ñ",
+		"%F1": "ñ",
+		"%f2": "ò",
+		"%F2": "ò",
+		"%f3": "ó",
+		"%F3": "ó",
+		"%f4": "ô",
+		"%F4": "ô",
+		"%f5": "õ",
+		"%F5": "õ",
+		"%f6": "ö",
+		"%F6": "ö",
+		"%f7": "÷",
+		"%F7": "÷",
+		"%f8": "ø",
+		"%F8": "ø",
+		"%f9": "ù",
+		"%F9": "ù",
+		"%fa": "ú",
+		"%Fa": "ú",
+		"%fA": "ú",
+		"%FA": "ú",
+		"%fb": "û",
+		"%Fb": "û",
+		"%fB": "û",
+		"%FB": "û",
+		"%fc": "ü",
+		"%Fc": "ü",
+		"%fC": "ü",
+		"%FC": "ü",
+		"%fd": "ý",
+		"%Fd": "ý",
+		"%fD": "ý",
+		"%FD": "ý",
+		"%fe": "þ",
+		"%Fe": "þ",
+		"%fE": "þ",
+		"%FE": "þ",
+		"%ff": "ÿ",
+		"%Ff": "ÿ",
+		"%fF": "ÿ",
+		"%FF": "ÿ"
+	};
+	function encodedReplacer(match) {
+		return EncodedLookup[match];
+	}
+	const STATE_KEY = 0;
+	const STATE_VALUE = 1;
+	const STATE_CHARSET = 2;
+	const STATE_LANG = 3;
+	function parseParams(str) {
+		const res = [];
+		let state = STATE_KEY;
+		let charset = "";
+		let inquote = false;
+		let escaping = false;
+		let p = 0;
+		let tmp = "";
+		const len = str.length;
+		for (var i = 0; i < len; ++i) {
+			const char = str[i];
+			if (char === "\\" && inquote) if (escaping) escaping = false;
+			else {
+				escaping = true;
+				continue;
+			}
+			else if (char === "\"") if (!escaping) {
+				if (inquote) {
+					inquote = false;
+					state = STATE_KEY;
+					while (i + 1 < len && str[i + 1] !== ";") ++i;
+				} else inquote = true;
+				continue;
+			} else escaping = false;
+			else {
+				if (escaping && inquote) tmp += "\\";
+				escaping = false;
+				if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
+					if (state === STATE_CHARSET) {
+						state = STATE_LANG;
+						charset = tmp.substring(1);
+					} else state = STATE_VALUE;
+					tmp = "";
+					continue;
+				} else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) {
+					state = char === "*" ? STATE_CHARSET : STATE_VALUE;
+					res[p] = [tmp, void 0];
+					tmp = "";
+					continue;
+				} else if (!inquote && char === ";") {
+					state = STATE_KEY;
+					if (charset) {
+						if (tmp.length) tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer), "binary", charset);
+						charset = "";
+					} else if (tmp.length) tmp = decodeText(tmp, "binary", "utf8");
+					if (res[p] === void 0) res[p] = tmp;
+					else res[p][1] = tmp;
+					tmp = "";
+					++p;
+					continue;
+				} else if (!inquote && (char === " " || char === "	")) continue;
+			}
+			tmp += char;
+		}
+		if (charset && tmp.length) tmp = decodeText(tmp.replace(RE_ENCODED, encodedReplacer), "binary", charset);
+		else if (tmp) tmp = decodeText(tmp, "binary", "utf8");
+		if (res[p] === void 0) {
+			if (tmp) res[p] = tmp;
+		} else res[p][1] = tmp;
+		return res;
+	}
+	module.exports = parseParams;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/utils/basename.js
+var require_basename = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function basename(path) {
+		if (typeof path !== "string") return "";
+		for (var i = path.length - 1; i >= 0; --i) switch (path.charCodeAt(i)) {
+			case 47:
+			case 92:
+				path = path.slice(i + 1);
+				return path === ".." || path === "." ? "" : path;
+		}
+		return path === ".." || path === "." ? "" : path;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/types/multipart.js
+var require_multipart$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { Readable: Readable$1 } = __require("node:stream");
+	const { inherits: inherits$1 } = __require("node:util");
+	const Dicer = require_Dicer();
+	const parseParams = require_parseParams();
+	const decodeText = require_decodeText();
+	const basename = require_basename();
+	const getLimit = require_getLimit();
+	const RE_BOUNDARY = /^boundary$/i;
+	const RE_FIELD = /^form-data$/i;
+	const RE_CHARSET = /^charset$/i;
+	const RE_FILENAME = /^filename$/i;
+	const RE_NAME = /^name$/i;
+	Multipart.detect = /^multipart\/form-data/i;
+	function Multipart(boy, cfg) {
+		let i;
+		let len;
+		const self = this;
+		let boundary;
+		const limits = cfg.limits;
+		const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0);
+		const parsedConType = cfg.parsedConType || [];
+		const defCharset = cfg.defCharset || "utf8";
+		const preservePath = cfg.preservePath;
+		const fileOpts = { highWaterMark: cfg.fileHwm };
+		for (i = 0, len = parsedConType.length; i < len; ++i) if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) {
+			boundary = parsedConType[i][1];
+			break;
+		}
+		function checkFinished() {
+			if (nends === 0 && finished && !boy._done) {
+				finished = false;
+				self.end();
+			}
+		}
+		if (typeof boundary !== "string") throw new Error("Multipart: Boundary not found");
+		const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
+		const fileSizeLimit = getLimit(limits, "fileSize", Infinity);
+		const filesLimit = getLimit(limits, "files", Infinity);
+		const fieldsLimit = getLimit(limits, "fields", Infinity);
+		const partsLimit = getLimit(limits, "parts", Infinity);
+		const headerPairsLimit = getLimit(limits, "headerPairs", 2e3);
+		const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024);
+		let nfiles = 0;
+		let nfields = 0;
+		let nends = 0;
+		let curFile;
+		let curField;
+		let finished = false;
+		this._needDrain = false;
+		this._pause = false;
+		this._cb = void 0;
+		this._nparts = 0;
+		this._boy = boy;
+		this.parser = new Dicer({
+			boundary,
+			maxHeaderPairs: headerPairsLimit,
+			maxHeaderSize: headerSizeLimit,
+			partHwm: fileOpts.highWaterMark,
+			highWaterMark: cfg.highWaterMark
+		});
+		this.parser.on("drain", function() {
+			self._needDrain = false;
+			if (self._cb && !self._pause) {
+				const cb = self._cb;
+				self._cb = void 0;
+				cb();
+			}
+		}).on("part", function onPart(part) {
+			if (++self._nparts > partsLimit) {
+				self.parser.removeListener("part", onPart);
+				self.parser.on("part", skipPart);
+				boy.hitPartsLimit = true;
+				boy.emit("partsLimit");
+				return skipPart(part);
+			}
+			if (curField) {
+				const field = curField;
+				field.emit("end");
+				field.removeAllListeners("end");
+			}
+			part.on("header", function(header) {
+				let contype;
+				let fieldname;
+				let parsed;
+				let charset;
+				let encoding;
+				let filename;
+				let nsize = 0;
+				if (header["content-type"]) {
+					parsed = parseParams(header["content-type"][0]);
+					if (parsed[0]) {
+						contype = parsed[0].toLowerCase();
+						for (i = 0, len = parsed.length; i < len; ++i) if (RE_CHARSET.test(parsed[i][0])) {
+							charset = parsed[i][1].toLowerCase();
+							break;
+						}
+					}
+				}
+				if (contype === void 0) contype = "text/plain";
+				if (charset === void 0) charset = defCharset;
+				if (header["content-disposition"]) {
+					parsed = parseParams(header["content-disposition"][0]);
+					if (!RE_FIELD.test(parsed[0])) return skipPart(part);
+					for (i = 0, len = parsed.length; i < len; ++i) if (RE_NAME.test(parsed[i][0])) fieldname = parsed[i][1];
+					else if (RE_FILENAME.test(parsed[i][0])) {
+						filename = parsed[i][1];
+						if (!preservePath) filename = basename(filename);
+					}
+				} else return skipPart(part);
+				if (header["content-transfer-encoding"]) encoding = header["content-transfer-encoding"][0].toLowerCase();
+				else encoding = "7bit";
+				let onData, onEnd;
+				if (isPartAFile(fieldname, contype, filename)) {
+					if (nfiles === filesLimit) {
+						if (!boy.hitFilesLimit) {
+							boy.hitFilesLimit = true;
+							boy.emit("filesLimit");
+						}
+						return skipPart(part);
+					}
+					++nfiles;
+					if (boy.listenerCount("file") === 0) {
+						self.parser._ignore();
+						return;
+					}
+					++nends;
+					const file = new FileStream(fileOpts);
+					curFile = file;
+					file.on("end", function() {
+						--nends;
+						self._pause = false;
+						checkFinished();
+						if (self._cb && !self._needDrain) {
+							const cb = self._cb;
+							self._cb = void 0;
+							cb();
+						}
+					});
+					file._read = function(n) {
+						if (!self._pause) return;
+						self._pause = false;
+						if (self._cb && !self._needDrain) {
+							const cb = self._cb;
+							self._cb = void 0;
+							cb();
+						}
+					};
+					boy.emit("file", fieldname, file, filename, encoding, contype);
+					onData = function(data) {
+						if ((nsize += data.length) > fileSizeLimit) {
+							const extralen = fileSizeLimit - nsize + data.length;
+							if (extralen > 0) file.push(data.slice(0, extralen));
+							file.truncated = true;
+							file.bytesRead = fileSizeLimit;
+							part.removeAllListeners("data");
+							file.emit("limit");
+							return;
+						} else if (!file.push(data)) self._pause = true;
+						file.bytesRead = nsize;
+					};
+					onEnd = function() {
+						curFile = void 0;
+						file.push(null);
+					};
+				} else {
+					if (nfields === fieldsLimit) {
+						if (!boy.hitFieldsLimit) {
+							boy.hitFieldsLimit = true;
+							boy.emit("fieldsLimit");
+						}
+						return skipPart(part);
+					}
+					++nfields;
+					++nends;
+					let buffer = "";
+					let truncated = false;
+					curField = part;
+					onData = function(data) {
+						if ((nsize += data.length) > fieldSizeLimit) {
+							const extralen = fieldSizeLimit - (nsize - data.length);
+							buffer += data.toString("binary", 0, extralen);
+							truncated = true;
+							part.removeAllListeners("data");
+						} else buffer += data.toString("binary");
+					};
+					onEnd = function() {
+						curField = void 0;
+						if (buffer.length) buffer = decodeText(buffer, "binary", charset);
+						boy.emit("field", fieldname, buffer, false, truncated, encoding, contype);
+						--nends;
+						checkFinished();
+					};
+				}
+				part._readableState.sync = false;
+				part.on("data", onData);
+				part.on("end", onEnd);
+			}).on("error", function(err) {
+				if (curFile) curFile.emit("error", err);
+			});
+		}).on("error", function(err) {
+			boy.emit("error", err);
+		}).on("finish", function() {
+			finished = true;
+			checkFinished();
+		});
+	}
+	Multipart.prototype.write = function(chunk, cb) {
+		const r = this.parser.write(chunk);
+		if (r && !this._pause) cb();
+		else {
+			this._needDrain = !r;
+			this._cb = cb;
+		}
+	};
+	Multipart.prototype.end = function() {
+		const self = this;
+		if (self.parser.writable) self.parser.end();
+		else if (!self._boy._done) process.nextTick(function() {
+			self._boy._done = true;
+			self._boy.emit("finish");
+		});
+	};
+	function skipPart(part) {
+		part.resume();
+	}
+	function FileStream(opts) {
+		Readable$1.call(this, opts);
+		this.bytesRead = 0;
+		this.truncated = false;
+	}
+	inherits$1(FileStream, Readable$1);
+	FileStream.prototype._read = function(n) {};
+	module.exports = Multipart;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/utils/Decoder.js
+var require_Decoder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const RE_PLUS = /\+/g;
+	const HEX = [
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+	function Decoder() {
+		this.buffer = void 0;
+	}
+	Decoder.prototype.write = function(str) {
+		str = str.replace(RE_PLUS, " ");
+		let res = "";
+		let i = 0;
+		let p = 0;
+		const len = str.length;
+		for (; i < len; ++i) if (this.buffer !== void 0) if (!HEX[str.charCodeAt(i)]) {
+			res += "%" + this.buffer;
+			this.buffer = void 0;
+			--i;
+		} else {
+			this.buffer += str[i];
+			++p;
+			if (this.buffer.length === 2) {
+				res += String.fromCharCode(parseInt(this.buffer, 16));
+				this.buffer = void 0;
+			}
+		}
+		else if (str[i] === "%") {
+			if (i > p) {
+				res += str.substring(p, i);
+				p = i;
+			}
+			this.buffer = "";
+			++p;
+		}
+		if (p < len && this.buffer === void 0) res += str.substring(p);
+		return res;
+	};
+	Decoder.prototype.reset = function() {
+		this.buffer = void 0;
+	};
+	module.exports = Decoder;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/types/urlencoded.js
+var require_urlencoded = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Decoder = require_Decoder();
+	const decodeText = require_decodeText();
+	const getLimit = require_getLimit();
+	const RE_CHARSET = /^charset$/i;
+	UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
+	function UrlEncoded(boy, cfg) {
+		const limits = cfg.limits;
+		const parsedConType = cfg.parsedConType;
+		this.boy = boy;
+		this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
+		this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100);
+		this.fieldsLimit = getLimit(limits, "fields", Infinity);
+		let charset;
+		for (var i = 0, len = parsedConType.length; i < len; ++i) if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) {
+			charset = parsedConType[i][1].toLowerCase();
+			break;
+		}
+		if (charset === void 0) charset = cfg.defCharset || "utf8";
+		this.decoder = new Decoder();
+		this.charset = charset;
+		this._fields = 0;
+		this._state = "key";
+		this._checkingBytes = true;
+		this._bytesKey = 0;
+		this._bytesVal = 0;
+		this._key = "";
+		this._val = "";
+		this._keyTrunc = false;
+		this._valTrunc = false;
+		this._hitLimit = false;
+	}
+	UrlEncoded.prototype.write = function(data, cb) {
+		if (this._fields === this.fieldsLimit) {
+			if (!this.boy.hitFieldsLimit) {
+				this.boy.hitFieldsLimit = true;
+				this.boy.emit("fieldsLimit");
+			}
+			return cb();
+		}
+		let idxeq;
+		let idxamp;
+		let i;
+		let p = 0;
+		const len = data.length;
+		while (p < len) if (this._state === "key") {
+			idxeq = idxamp = void 0;
+			for (i = p; i < len; ++i) {
+				if (!this._checkingBytes) ++p;
+				if (data[i] === 61) {
+					idxeq = i;
+					break;
+				} else if (data[i] === 38) {
+					idxamp = i;
+					break;
+				}
+				if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
+					this._hitLimit = true;
+					break;
+				} else if (this._checkingBytes) ++this._bytesKey;
+			}
+			if (idxeq !== void 0) {
+				if (idxeq > p) this._key += this.decoder.write(data.toString("binary", p, idxeq));
+				this._state = "val";
+				this._hitLimit = false;
+				this._checkingBytes = true;
+				this._val = "";
+				this._bytesVal = 0;
+				this._valTrunc = false;
+				this.decoder.reset();
+				p = idxeq + 1;
+			} else if (idxamp !== void 0) {
+				++this._fields;
+				let key;
+				const keyTrunc = this._keyTrunc;
+				if (idxamp > p) key = this._key += this.decoder.write(data.toString("binary", p, idxamp));
+				else key = this._key;
+				this._hitLimit = false;
+				this._checkingBytes = true;
+				this._key = "";
+				this._bytesKey = 0;
+				this._keyTrunc = false;
+				this.decoder.reset();
+				if (key.length) this.boy.emit("field", decodeText(key, "binary", this.charset), "", keyTrunc, false);
+				p = idxamp + 1;
+				if (this._fields === this.fieldsLimit) return cb();
+			} else if (this._hitLimit) {
+				if (i > p) this._key += this.decoder.write(data.toString("binary", p, i));
+				p = i;
+				if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
+					this._checkingBytes = false;
+					this._keyTrunc = true;
+				}
+			} else {
+				if (p < len) this._key += this.decoder.write(data.toString("binary", p));
+				p = len;
+			}
+		} else {
+			idxamp = void 0;
+			for (i = p; i < len; ++i) {
+				if (!this._checkingBytes) ++p;
+				if (data[i] === 38) {
+					idxamp = i;
+					break;
+				}
+				if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
+					this._hitLimit = true;
+					break;
+				} else if (this._checkingBytes) ++this._bytesVal;
+			}
+			if (idxamp !== void 0) {
+				++this._fields;
+				if (idxamp > p) this._val += this.decoder.write(data.toString("binary", p, idxamp));
+				this.boy.emit("field", decodeText(this._key, "binary", this.charset), decodeText(this._val, "binary", this.charset), this._keyTrunc, this._valTrunc);
+				this._state = "key";
+				this._hitLimit = false;
+				this._checkingBytes = true;
+				this._key = "";
+				this._bytesKey = 0;
+				this._keyTrunc = false;
+				this.decoder.reset();
+				p = idxamp + 1;
+				if (this._fields === this.fieldsLimit) return cb();
+			} else if (this._hitLimit) {
+				if (i > p) this._val += this.decoder.write(data.toString("binary", p, i));
+				p = i;
+				if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
+					this._checkingBytes = false;
+					this._valTrunc = true;
+				}
+			} else {
+				if (p < len) this._val += this.decoder.write(data.toString("binary", p));
+				p = len;
+			}
+		}
+		cb();
+	};
+	UrlEncoded.prototype.end = function() {
+		if (this.boy._done) return;
+		if (this._state === "key" && this._key.length > 0) this.boy.emit("field", decodeText(this._key, "binary", this.charset), "", this._keyTrunc, false);
+		else if (this._state === "val") this.boy.emit("field", decodeText(this._key, "binary", this.charset), decodeText(this._val, "binary", this.charset), this._keyTrunc, this._valTrunc);
+		this.boy._done = true;
+		this.boy.emit("finish");
+	};
+	module.exports = UrlEncoded;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+busboy@3.2.0/node_modules/@fastify/busboy/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const WritableStream = __require("node:stream").Writable;
+	const { inherits } = __require("node:util");
+	const Dicer = require_Dicer();
+	const MultipartParser = require_multipart$1();
+	const UrlencodedParser = require_urlencoded();
+	const parseParams = require_parseParams();
+	function Busboy(opts) {
+		if (!(this instanceof Busboy)) return new Busboy(opts);
+		if (typeof opts !== "object") throw new TypeError("Busboy expected an options-Object.");
+		if (typeof opts.headers !== "object") throw new TypeError("Busboy expected an options-Object with headers-attribute.");
+		if (typeof opts.headers["content-type"] !== "string") throw new TypeError("Missing Content-Type-header.");
+		const { headers, ...streamOptions } = opts;
+		this.opts = {
+			autoDestroy: false,
+			...streamOptions
+		};
+		WritableStream.call(this, this.opts);
+		this._done = false;
+		this._parser = this.getParserByHeaders(headers);
+		this._finished = false;
+	}
+	inherits(Busboy, WritableStream);
+	Busboy.prototype.emit = function(ev) {
+		if (ev === "finish") {
+			if (!this._done) {
+				this._parser?.end();
+				return;
+			} else if (this._finished) return;
+			this._finished = true;
+		}
+		WritableStream.prototype.emit.apply(this, arguments);
+	};
+	Busboy.prototype.getParserByHeaders = function(headers) {
+		const parsed = parseParams(headers["content-type"]);
+		const cfg = {
+			defCharset: this.opts.defCharset,
+			fileHwm: this.opts.fileHwm,
+			headers,
+			highWaterMark: this.opts.highWaterMark,
+			isPartAFile: this.opts.isPartAFile,
+			limits: this.opts.limits,
+			parsedConType: parsed,
+			preservePath: this.opts.preservePath
+		};
+		if (MultipartParser.detect.test(parsed[0])) return new MultipartParser(this, cfg);
+		if (UrlencodedParser.detect.test(parsed[0])) return new UrlencodedParser(this, cfg);
+		throw new Error("Unsupported Content-Type.");
+	};
+	Busboy.prototype._write = function(chunk, encoding, cb) {
+		this._parser.write(chunk, cb);
+	};
+	module.exports = Busboy;
+	module.exports.default = Busboy;
+	module.exports.Busboy = Busboy;
+	module.exports.Dicer = Dicer;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/lib/getPluginName.js
+var require_getPluginName = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fpStackTracePattern = /at\s(?:.*\.)?plugin\s.*\n\s*(.*)/;
+	const fileNamePattern = /(\w*(\.\w*)*)\..*/;
+	module.exports = function getPluginName(fn) {
+		if (fn.name.length > 0) return fn.name;
+		const stackTraceLimit = Error.stackTraceLimit;
+		Error.stackTraceLimit = 10;
 		try {
-			const assistant = await createAgentViaAdmin(serverUrl, accessToken, {
-				name: args.assistant,
-				type: "personal_assistant",
-				displayName: args.assistant,
-				metadata: {
-					role: `Personal Assistant to ${args.id}`,
-					domains: ["message triage", "task coordination"]
-				},
-				clientId: args.clientId
+			throw new Error("anonymous function");
+		} catch (e) {
+			Error.stackTraceLimit = stackTraceLimit;
+			return extractPluginName(e.stack);
+		}
+	};
+	function extractPluginName(stack) {
+		const m = stack.match(fpStackTracePattern);
+		return m ? m[1].split(/[/\\]/).slice(-1)[0].match(fileNamePattern)[1] : "anonymous";
+	}
+	module.exports.extractPluginName = extractPluginName;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/lib/toCamelCase.js
+var require_toCamelCase = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function toCamelCase(name) {
+		if (name[0] === "@") name = name.slice(1).replace("/", "-");
+		return name.replace(/-(.)/g, function(match, g1) {
+			return g1.toUpperCase();
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/fastify-plugin@5.1.0/node_modules/fastify-plugin/plugin.js
+var require_plugin = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const getPluginName = require_getPluginName();
+	const toCamelCase = require_toCamelCase();
+	let count = 0;
+	function plugin(fn, options = {}) {
+		let autoName = false;
+		if (fn.default !== void 0) fn = fn.default;
+		if (typeof fn !== "function") throw new TypeError(`fastify-plugin expects a function, instead got a '${typeof fn}'`);
+		if (typeof options === "string") options = { fastify: options };
+		if (typeof options !== "object" || Array.isArray(options) || options === null) throw new TypeError("The options object should be an object");
+		if (options.fastify !== void 0 && typeof options.fastify !== "string") throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof options.fastify}'`);
+		if (!options.name) {
+			autoName = true;
+			options.name = getPluginName(fn) + "-auto-" + count++;
+		}
+		fn[Symbol.for("skip-override")] = options.encapsulate !== true;
+		fn[Symbol.for("fastify.display-name")] = options.name;
+		fn[Symbol.for("plugin-meta")] = options;
+		if (!fn.default) fn.default = fn;
+		const camelCase = toCamelCase(options.name);
+		if (!autoName && !fn[camelCase]) fn[camelCase] = fn;
+		return fn;
+	}
+	module.exports = plugin;
+	module.exports.default = plugin;
+	module.exports.fastifyPlugin = plugin;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+multipart@10.0.0/node_modules/@fastify/multipart/lib/generateId.js
+var require_generateId = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const HEX = [
+		"00",
+		"01",
+		"02",
+		"03",
+		"04",
+		"05",
+		"06",
+		"07",
+		"08",
+		"09",
+		"0a",
+		"0b",
+		"0c",
+		"0d",
+		"0e",
+		"0f",
+		"10",
+		"11",
+		"12",
+		"13",
+		"14",
+		"15",
+		"16",
+		"17",
+		"18",
+		"19",
+		"1a",
+		"1b",
+		"1c",
+		"1d",
+		"1e",
+		"1f",
+		"20",
+		"21",
+		"22",
+		"23",
+		"24",
+		"25",
+		"26",
+		"27",
+		"28",
+		"29",
+		"2a",
+		"2b",
+		"2c",
+		"2d",
+		"2e",
+		"2f",
+		"30",
+		"31",
+		"32",
+		"33",
+		"34",
+		"35",
+		"36",
+		"37",
+		"38",
+		"39",
+		"3a",
+		"3b",
+		"3c",
+		"3d",
+		"3e",
+		"3f",
+		"40",
+		"41",
+		"42",
+		"43",
+		"44",
+		"45",
+		"46",
+		"47",
+		"48",
+		"49",
+		"4a",
+		"4b",
+		"4c",
+		"4d",
+		"4e",
+		"4f",
+		"50",
+		"51",
+		"52",
+		"53",
+		"54",
+		"55",
+		"56",
+		"57",
+		"58",
+		"59",
+		"5a",
+		"5b",
+		"5c",
+		"5d",
+		"5e",
+		"5f",
+		"60",
+		"61",
+		"62",
+		"63",
+		"64",
+		"65",
+		"66",
+		"67",
+		"68",
+		"69",
+		"6a",
+		"6b",
+		"6c",
+		"6d",
+		"6e",
+		"6f",
+		"70",
+		"71",
+		"72",
+		"73",
+		"74",
+		"75",
+		"76",
+		"77",
+		"78",
+		"79",
+		"7a",
+		"7b",
+		"7c",
+		"7d",
+		"7e",
+		"7f",
+		"80",
+		"81",
+		"82",
+		"83",
+		"84",
+		"85",
+		"86",
+		"87",
+		"88",
+		"89",
+		"8a",
+		"8b",
+		"8c",
+		"8d",
+		"8e",
+		"8f",
+		"90",
+		"91",
+		"92",
+		"93",
+		"94",
+		"95",
+		"96",
+		"97",
+		"98",
+		"99",
+		"9a",
+		"9b",
+		"9c",
+		"9d",
+		"9e",
+		"9f",
+		"a0",
+		"a1",
+		"a2",
+		"a3",
+		"a4",
+		"a5",
+		"a6",
+		"a7",
+		"a8",
+		"a9",
+		"aa",
+		"ab",
+		"ac",
+		"ad",
+		"ae",
+		"af",
+		"b0",
+		"b1",
+		"b2",
+		"b3",
+		"b4",
+		"b5",
+		"b6",
+		"b7",
+		"b8",
+		"b9",
+		"ba",
+		"bb",
+		"bc",
+		"bd",
+		"be",
+		"bf",
+		"c0",
+		"c1",
+		"c2",
+		"c3",
+		"c4",
+		"c5",
+		"c6",
+		"c7",
+		"c8",
+		"c9",
+		"ca",
+		"cb",
+		"cc",
+		"cd",
+		"ce",
+		"cf",
+		"d0",
+		"d1",
+		"d2",
+		"d3",
+		"d4",
+		"d5",
+		"d6",
+		"d7",
+		"d8",
+		"d9",
+		"da",
+		"db",
+		"dc",
+		"dd",
+		"de",
+		"df",
+		"e0",
+		"e1",
+		"e2",
+		"e3",
+		"e4",
+		"e5",
+		"e6",
+		"e7",
+		"e8",
+		"e9",
+		"ea",
+		"eb",
+		"ec",
+		"ed",
+		"ee",
+		"ef",
+		"f0",
+		"f1",
+		"f2",
+		"f3",
+		"f4",
+		"f5",
+		"f6",
+		"f7",
+		"f8",
+		"f9",
+		"fa",
+		"fb",
+		"fc",
+		"fd",
+		"fe",
+		"ff"
+	];
+	const random = Math.random;
+	function seed() {
+		return HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0];
+	}
+	module.exports.generateId = (function generateIdFn() {
+		let num = 0;
+		let str = seed();
+		return function generateId() {
+			return num === 255 ? (str = seed()) + HEX[num = 0] : str + HEX[++num];
+		};
+	})();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+error@4.2.0/node_modules/@fastify/error/index.js
+var require_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const { format } = __require("node:util");
+	function toString() {
+		return `${this.name} [${this.code}]: ${this.message}`;
+	}
+	const FastifyGenericErrorSymbol = Symbol.for("fastify-error-generic");
+	function createError(code, message, statusCode = 500, Base = Error, captureStackTrace = createError.captureStackTrace) {
+		const shouldCreateFastifyGenericError = code === FastifyGenericErrorSymbol;
+		if (shouldCreateFastifyGenericError) code = "FST_ERR";
+		if (!code) throw new Error("Fastify error code must not be empty");
+		if (!message) throw new Error("Fastify error message must not be empty");
+		code = code.toUpperCase();
+		!statusCode && (statusCode = void 0);
+		const FastifySpecificErrorSymbol = Symbol.for(`fastify-error ${code}`);
+		function FastifyError(...args) {
+			if (!new.target) return new FastifyError(...args);
+			this.code = code;
+			this.name = "FastifyError";
+			this.statusCode = statusCode;
+			const lastElement = args.length - 1;
+			if (lastElement !== -1 && args[lastElement] && typeof args[lastElement] === "object" && "cause" in args[lastElement]) this.cause = args.pop().cause;
+			this.message = format(message, ...args);
+			Error.stackTraceLimit && captureStackTrace && Error.captureStackTrace(this, FastifyError);
+		}
+		FastifyError.prototype = Object.create(Base.prototype, {
+			constructor: {
+				value: FastifyError,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			},
+			[FastifyGenericErrorSymbol]: {
+				value: true,
+				enumerable: false,
+				writable: false,
+				configurable: false
+			},
+			[FastifySpecificErrorSymbol]: {
+				value: true,
+				enumerable: false,
+				writable: false,
+				configurable: false
+			}
+		});
+		if (shouldCreateFastifyGenericError) Object.defineProperty(FastifyError, Symbol.hasInstance, {
+			value(instance) {
+				return instance && instance[FastifyGenericErrorSymbol];
+			},
+			configurable: false,
+			writable: false,
+			enumerable: false
+		});
+		else Object.defineProperty(FastifyError, Symbol.hasInstance, {
+			value(instance) {
+				return instance && instance[FastifySpecificErrorSymbol];
+			},
+			configurable: false,
+			writable: false,
+			enumerable: false
+		});
+		FastifyError.prototype[Symbol.toStringTag] = "Error";
+		FastifyError.prototype.toString = toString;
+		return FastifyError;
+	}
+	createError.captureStackTrace = true;
+	const FastifyErrorConstructor = createError(FastifyGenericErrorSymbol, "Fastify Error", 500, Error);
+	module.exports = createError;
+	module.exports.FastifyError = FastifyErrorConstructor;
+	module.exports.default = createError;
+	module.exports.createError = createError;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+multipart@10.0.0/node_modules/@fastify/multipart/lib/stream-consumer.js
+var require_stream_consumer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function streamToNull(stream) {
+		return new Promise((resolve, reject) => {
+			stream.on("data", () => {});
+			stream.on("close", () => {
+				resolve();
 			});
-			assistantUuid = assistant.uuid;
-			saveAgentConfig(args.assistant, assistant.uuid, "claude-code");
-			process.stderr.write(`Assistant "${args.assistant}" ready.\n`);
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			process.stderr.write(`Warning: Failed to create assistant "${args.assistant}": ${msg}\n`);
+			stream.on("end", () => {
+				resolve();
+			});
+			stream.on("error", (error) => {
+				reject(error);
+			});
+		});
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@fastify+deepmerge@3.2.1/node_modules/@fastify/deepmerge/index.js
+var require_deepmerge = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const JSON_PROTO = Object.getPrototypeOf({});
+	function defaultIsMergeableObjectFactory() {
+		return function defaultIsMergeableObject(value) {
+			return typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Date);
+		};
+	}
+	function deepmergeConstructor(options) {
+		function isNotPrototypeKey(value) {
+			return value !== "constructor" && value !== "prototype" && value !== "__proto__";
+		}
+		function cloneArray(value) {
+			let i = 0;
+			const il = value.length;
+			const result = new Array(il);
+			for (; i < il; ++i) result[i] = clone(value[i]);
+			return result;
+		}
+		function cloneObject(target) {
+			const result = {};
+			if (cloneProtoObject && Object.getPrototypeOf(target) !== JSON_PROTO) return cloneProtoObject(target);
+			const targetKeys = getKeys(target);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && (result[key] = clone(target[key]));
+			return result;
+		}
+		function concatArrays(target, source) {
+			const tl = target.length;
+			const sl = source.length;
+			let i = 0;
+			const result = new Array(tl + sl);
+			for (; i < tl; ++i) result[i] = clone(target[i]);
+			for (i = 0; i < sl; ++i) result[i + tl] = clone(source[i]);
+			return result;
+		}
+		const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+		function getSymbolsAndKeys(value) {
+			const result = Object.keys(value);
+			const keys = Object.getOwnPropertySymbols(value);
+			for (let i = 0, il = keys.length; i < il; ++i) propertyIsEnumerable.call(value, keys[i]) && result.push(keys[i]);
+			return result;
+		}
+		const getKeys = options?.symbols ? getSymbolsAndKeys : Object.keys;
+		const cloneProtoObject = typeof options?.cloneProtoObject === "function" ? options.cloneProtoObject : void 0;
+		const isMergeableObject = typeof options?.isMergeableObject === "function" ? options.isMergeableObject : defaultIsMergeableObjectFactory();
+		const onlyDefinedProperties = options?.onlyDefinedProperties === true;
+		function isPrimitive(value) {
+			return typeof value !== "object" || value === null;
+		}
+		const mergeArray = options && typeof options.mergeArray === "function" ? options.mergeArray({
+			clone,
+			deepmerge: _deepmerge,
+			getKeys,
+			isMergeableObject
+		}) : concatArrays;
+		function clone(entry) {
+			return isMergeableObject(entry) ? Array.isArray(entry) ? cloneArray(entry) : cloneObject(entry) : entry;
+		}
+		function mergeObject(target, source) {
+			const result = {};
+			const targetKeys = getKeys(target);
+			const sourceKeys = getKeys(source);
+			let i, il, key;
+			for (i = 0, il = targetKeys.length; i < il; ++i) isNotPrototypeKey(key = targetKeys[i]) && sourceKeys.indexOf(key) === -1 && (result[key] = clone(target[key]));
+			for (i = 0, il = sourceKeys.length; i < il; ++i) {
+				if (!isNotPrototypeKey(key = sourceKeys[i])) continue;
+				if (key in target) {
+					if (targetKeys.indexOf(key) !== -1) if (cloneProtoObject && isMergeableObject(source[key]) && Object.getPrototypeOf(source[key]) !== JSON_PROTO) result[key] = cloneProtoObject(source[key]);
+					else result[key] = _deepmerge(target[key], source[key]);
+				} else {
+					if (onlyDefinedProperties && typeof source[key] === "undefined") continue;
+					result[key] = clone(source[key]);
+				}
+			}
+			return result;
+		}
+		function _deepmerge(target, source) {
+			if (onlyDefinedProperties && typeof source === "undefined") return clone(target);
+			const sourceIsArray = Array.isArray(source);
+			const targetIsArray = Array.isArray(target);
+			if (isPrimitive(source)) return source;
+			else if (!isMergeableObject(target)) return clone(source);
+			else if (sourceIsArray && targetIsArray) return mergeArray(target, source);
+			else if (sourceIsArray !== targetIsArray) return clone(source);
+			else return mergeObject(target, source);
+		}
+		function _deepmergeAll() {
+			switch (arguments.length) {
+				case 0: return {};
+				case 1: return clone(arguments[0]);
+				case 2: return _deepmerge(arguments[0], arguments[1]);
+			}
+			let result;
+			for (let i = 0, il = arguments.length; i < il; ++i) result = _deepmerge(result, arguments[i]);
+			return result;
 		}
+		return options?.all ? _deepmergeAll : _deepmerge;
 	}
-	const runtimeAgent = args.type === "human" ? args.assistant : args.id;
-	if (args.feishuBotAppId && args.feishuBotAppSecret) {
-		const { bindFeishuBot } = await import("./feishu-n9Y2yGTT.mjs").then((n) => n.r);
-		const targetAgentUuid = args.type === "human" ? assistantUuid : primary.uuid;
-		if (!targetAgentUuid) process.stderr.write(`Warning: Cannot bind Feishu bot — no runtime agent available for "${args.id}".\n`);
-		else {
-			process.stderr.write("Binding Feishu bot...\n");
-			await bindFeishuBot(serverUrl, accessToken, targetAgentUuid, args.feishuBotAppId, args.feishuBotAppSecret);
-			process.stderr.write("Feishu bot bound.\n");
+	module.exports = deepmergeConstructor;
+	module.exports.default = deepmergeConstructor;
+	module.exports.deepmerge = deepmergeConstructor;
+	Object.defineProperty(module.exports, "isMergeableObject", { get: defaultIsMergeableObjectFactory });
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/secure-json-parse@4.1.0/node_modules/secure-json-parse/index.js
+var require_secure_json_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const hasBuffer = typeof Buffer !== "undefined";
+	const suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+	const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+	/**
+	* @description Internal parse function that parses JSON text with security checks.
+	* @private
+	* @param {string|Buffer} text - The JSON text string or Buffer to parse.
+	* @param {Function} [reviver] - The JSON.parse() optional reviver argument.
+	* @param {import('./types').ParseOptions} [options] - Optional configuration object.
+	* @returns {*} The parsed object.
+	* @throws {SyntaxError} If a forbidden prototype property is found and `options.protoAction` or
+	* `options.constructorAction` is `'error'`.
+	*/
+	function _parse(text, reviver, options) {
+		if (options == null) {
+			if (reviver !== null && typeof reviver === "object") {
+				options = reviver;
+				reviver = void 0;
+			}
 		}
+		if (hasBuffer && Buffer.isBuffer(text)) text = text.toString();
+		if (text && text.charCodeAt(0) === 65279) text = text.slice(1);
+		const obj = JSON.parse(text, reviver);
+		if (obj === null || typeof obj !== "object") return obj;
+		const protoAction = options && options.protoAction || "error";
+		const constructorAction = options && options.constructorAction || "error";
+		if (protoAction === "ignore" && constructorAction === "ignore") return obj;
+		if (protoAction !== "ignore" && constructorAction !== "ignore") {
+			if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) return obj;
+		} else if (protoAction !== "ignore" && constructorAction === "ignore") {
+			if (suspectProtoRx.test(text) === false) return obj;
+		} else if (suspectConstructorRx.test(text) === false) return obj;
+		return filter(obj, {
+			protoAction,
+			constructorAction,
+			safe: options && options.safe
+		});
 	}
-	setConfigValue(join(DEFAULT_CONFIG_DIR, "client.yaml"), "server.url", serverUrl);
-	try {
-		const { unlinkSync } = await import("node:fs");
-		unlinkSync(STATE_FILE);
-	} catch {}
-	const typeLabel = args.type === "human" ? "Human" : args.type === "autonomous_agent" ? "Agent" : "Assistant";
-	process.stderr.write("\n✅ Onboard complete!\n\n");
-	process.stderr.write(`  ${typeLabel}:${" ".repeat(Math.max(1, 10 - typeLabel.length))}${args.id}\n`);
-	if (args.assistant) process.stderr.write(`  Assistant: ${args.assistant}\n`);
-	if (runtimeAgent) process.stderr.write(`  Config:    ${DEFAULT_HOME_DIR$1}/config/agents/${runtimeAgent}/agent.yaml\n`);
-	if (args.feishuBotAppId) process.stderr.write(`  Feishu:    bot bound (${args.feishuBotAppId})\n`);
-	if (args.type === "human") {
-		process.stderr.write("\n  Next step — bind your Feishu account:\n");
-		process.stderr.write(`    Send this message to the bot in Feishu:  /bind ${args.id}\n`);
-		if (!args.feishuBotAppId) process.stderr.write("    (requires a Feishu bot to be configured in the system)\n");
+	/**
+	* @description Scans and filters an object for forbidden prototype properties.
+	* @param {Object} obj - The object being scanned.
+	* @param {import('./types').ParseOptions} [options] - Optional configuration object.
+	* @returns {Object|null} The filtered object, or `null` if safe mode is enabled and issues are found.
+	* @throws {SyntaxError} If a forbidden prototype property is found and `options.protoAction` or
+	* `options.constructorAction` is `'error'`.
+	*/
+	function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+		let next = [obj];
+		while (next.length) {
+			const nodes = next;
+			next = [];
+			for (const node of nodes) {
+				if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+					if (safe === true) return null;
+					else if (protoAction === "error") throw new SyntaxError("Object contains forbidden prototype property");
+					delete node.__proto__;
+				}
+				if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+					if (safe === true) return null;
+					else if (constructorAction === "error") throw new SyntaxError("Object contains forbidden prototype property");
+					delete node.constructor;
+				}
+				for (const key in node) {
+					const value = node[key];
+					if (value && typeof value === "object") next.push(value);
+				}
+			}
+		}
+		return obj;
 	}
-	if (runtimeAgent) {
-		process.stderr.write("\n  Start the agent:\n");
-		process.stderr.write("    first-tree-hub client start\n");
+	/**
+	* @description Parses a given JSON-formatted text into an object.
+	* @param {string|Buffer} text - The JSON text string or Buffer to parse.
+	* @param {Function} [reviver] - The `JSON.parse()` optional reviver argument, or options object.
+	* @param {import('./types').ParseOptions} [options] - Optional configuration object.
+	* @returns {*} The parsed object.
+	* @throws {SyntaxError} If the JSON text is malformed or contains forbidden prototype properties
+	* when `options.protoAction` or `options.constructorAction` is `'error'`.
+	*/
+	function parse(text, reviver, options) {
+		const { stackTraceLimit } = Error;
+		Error.stackTraceLimit = 0;
+		try {
+			return _parse(text, reviver, options);
+		} finally {
+			Error.stackTraceLimit = stackTraceLimit;
+		}
 	}
-	process.stderr.write("\n");
-}
-//#endregion
-//#region src/core/prompt.ts
-/**
-* Check if interactive mode is available.
-* Returns false if --no-interactive flag is set or stdin is not a TTY.
-*/
-function isInteractive(noInteractiveFlag) {
-	if (noInteractiveFlag) return false;
-	return process.stdin.isTTY === true;
-}
-/**
-* Schema-driven interactive setup.
-* Scans the config schema for fields with `prompt` that are missing.
-*
-* In interactive mode: prompts the user and writes results to YAML.
-* In non-interactive mode: fails with a clear error listing missing fields.
-*/
-async function promptMissingFields(options) {
-	const missing = collectMissingPrompts({
-		schema: options.schema,
-		role: options.role,
-		configDir: options.configDir,
-		cliArgs: options.cliArgs
-	});
-	if (missing.length === 0) return {};
-	if (!isInteractive(options.noInteractive)) {
-		const lines = missing.map((m) => {
-			const envHint = findEnvVar(options.schema, m.dotPath);
-			const envStr = envHint ? `  (env: ${envHint})` : "";
-			return `  ${m.dotPath}${envStr}`;
-		});
-		throw new Error(`Missing required configuration:\n${lines.join("\n")}\n\nProvide values via environment variables, config file (${DEFAULT_HOME_DIR$1}/server.yaml),\nor run without --no-interactive to use the interactive setup wizard.`);
+	/**
+	* @description Safely parses a given JSON-formatted text into an object.
+	* @param {string|Buffer} text - The JSON text string or Buffer to parse.
+	* @param {Function} [reviver] - The `JSON.parse()` optional reviver argument.
+	* @returns {*|null|undefined} The parsed object, `null` if security issues found, or `undefined` on parse error.
+	*/
+	function safeParse(text, reviver) {
+		const { stackTraceLimit } = Error;
+		Error.stackTraceLimit = 0;
+		try {
+			return _parse(text, reviver, { safe: true });
+		} catch {
+			return;
+		} finally {
+			Error.stackTraceLimit = stackTraceLimit;
+		}
 	}
-	const configPath = join(options.configDir ?? DEFAULT_CONFIG_DIR, `${options.role}.yaml`);
-	const results = {};
-	for (const { dotPath, prompt } of missing) {
-		const value = await askPrompt(dotPath, prompt);
-		if (value !== void 0) {
-			setConfigValue(configPath, dotPath, value);
-			setNestedByDot(results, dotPath, value);
+	module.exports = parse;
+	module.exports.default = parse;
+	module.exports.parse = parse;
+	module.exports.safeParse = safeParse;
+	module.exports.scan = filter;
+}));
+//#endregion
+//#region ../server/dist/app-BDvasXc4.mjs
+var import_multipart = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const Busboy = require_main();
+	const os = __require("node:os");
+	const fp = require_plugin();
+	const { createWriteStream: createWriteStream$1 } = __require("node:fs");
+	const { unlink } = __require("node:fs/promises");
+	const path = __require("node:path");
+	const { generateId } = require_generateId();
+	const createError = require_error();
+	const streamToNull = require_stream_consumer();
+	const deepmergeAll = require_deepmerge()({ all: true });
+	const { PassThrough, Readable } = __require("node:stream");
+	const { pipeline: pump } = __require("node:stream/promises");
+	const secureJSON = require_secure_json_parse();
+	const kMultipart = Symbol("multipart");
+	const kMultipartHandler = Symbol("multipartHandler");
+	const kSavedRequestFilesResult = Symbol("savedRequestFilesResult");
+	const PartsLimitError = createError("FST_PARTS_LIMIT", "reach parts limit", 413);
+	const FilesLimitError = createError("FST_FILES_LIMIT", "reach files limit", 413);
+	const FieldsLimitError = createError("FST_FIELDS_LIMIT", "reach fields limit", 413);
+	const RequestFileTooLargeError = createError("FST_REQ_FILE_TOO_LARGE", "request file too large", 413);
+	const PrototypeViolationError = createError("FST_PROTO_VIOLATION", "prototype property is not allowed as field name", 400);
+	const InvalidMultipartContentTypeError = createError("FST_INVALID_MULTIPART_CONTENT_TYPE", "the request is not multipart", 406);
+	const InvalidJSONFieldError = createError("FST_INVALID_JSON_FIELD_ERROR", "a request field is not a valid JSON as declared by its Content-Type", 406);
+	const FileBufferNotFoundError = createError("FST_FILE_BUFFER_NOT_FOUND", "the file buffer was not found", 500);
+	const NoFormData = createError("FST_NO_FORM_DATA", "FormData is not available", 500);
+	function setMultipart(req, _payload, done) {
+		req[kMultipart] = true;
+		done();
+	}
+	function busboy(options) {
+		try {
+			return new Busboy(options);
+		} catch (error) {
+			const errorEmitter = new PassThrough();
+			process.nextTick(function() {
+				errorEmitter.emit("error", error);
+			});
+			return errorEmitter;
 		}
 	}
-	return results;
-}
-/**
-* Interactive add agent — simple two-field prompt.
-*/
-async function promptAddAgent() {
-	return {
-		name: await input({
-			message: "Local alias:",
-			validate: (v) => /^[a-z0-9][a-z0-9-]*$/.test(v) ? true : "Lowercase alphanumeric and hyphens only"
-		}),
-		agentId: await input({
-			message: "Agent UUID on the Hub:",
-			validate: (v) => v.length > 0 ? true : "Agent UUID is required"
-		})
-	};
-}
-async function askPrompt(dotPath, prompt) {
-	const type = prompt.type ?? "input";
-	if (type === "select" && prompt.choices) {
-		const value = await select({
-			message: prompt.message,
-			choices: prompt.choices.map((c) => ({
-				name: c.name,
-				value: c.value
-			}))
+	function fastifyMultipart(fastify, options, done) {
+		options.limits = {
+			...options.limits,
+			parts: options.limits?.parts || 1e3,
+			fileSize: options.limits?.fileSize || fastify.initialConfig.bodyLimit
+		};
+		const attachFieldsToBody = options.attachFieldsToBody;
+		if (attachFieldsToBody === true || attachFieldsToBody === "keyValues") {
+			if (typeof options.sharedSchemaId === "string" && attachFieldsToBody === true) fastify.addSchema({
+				$id: options.sharedSchemaId,
+				type: "object",
+				properties: {
+					fieldname: { type: "string" },
+					encoding: { type: "string" },
+					filename: { type: "string" },
+					mimetype: { type: "string" }
+				}
+			});
+			fastify.addHook("preValidation", async function(req) {
+				if (!req.isMultipart()) return;
+				for await (const part of req.parts(req.routeOptions.config.multipartOptions)) {
+					req.body = part.fields;
+					if (part.file) if (options.onFile) await options.onFile.call(req, part);
+					else await part.toBuffer();
+				}
+				if (attachFieldsToBody === "keyValues") {
+					const body = {};
+					if (req.body) {
+						const reqBodyKeys = Object.keys(req.body);
+						for (let i = 0; i < reqBodyKeys.length; ++i) {
+							const key = reqBodyKeys[i];
+							const field = req.body[key];
+							if (field.value !== void 0) body[key] = field.value;
+							else if (field._buf) body[key] = field._buf;
+							else if (Array.isArray(field)) {
+								const items = [];
+								for (let i = 0; i < field.length; ++i) {
+									const item = field[i];
+									if (item.value !== void 0) items.push(item.value);
+									else if (item._buf) items.push(item._buf);
+								}
+								if (items.length) body[key] = items;
+							}
+						}
+					}
+					req.body = body;
+				}
+			});
+			/* istanbul ignore next */
+			if (globalThis.FormData && !fastify.hasRequestDecorator("formData")) fastify.decorateRequest("formData", async function() {
+				const formData = new FormData();
+				for (const key in this.body) {
+					const value = this.body[key];
+					if (Array.isArray(value)) for (const item of value) await append(key, item);
+					else await append(key, value);
+				}
+				async function append(key, entry) {
+					/* c8 ignore next: Buffer.isBuffer is not covered and causing `npm test` to fail */
+					if (entry.type === "file" || attachFieldsToBody === "keyValues" && Buffer.isBuffer(entry)) formData.append(key, new Blob([await entry.toBuffer()], { type: entry.mimetype }), entry.filename);
+					else formData.append(key, entry.value);
+				}
+				return formData;
+			});
+		}
+		/* istanbul ignore next */
+		if (!fastify.hasRequestDecorator("formData")) fastify.decorateRequest("formData", async function() {
+			/* c8 ignore next: Next line is not covered and causing `npm test` to fail */
+			throw new NoFormData();
 		});
-		if (value === "__auto__") return void 0;
-		if (value === "__input__") return input({
-			message: `${dotPath}:`,
-			validate: (v) => v.length > 0 ? true : "Value is required"
+		const defaultThrowFileSizeLimit = typeof options.throwFileSizeLimit === "boolean" ? options.throwFileSizeLimit : true;
+		fastify.decorate("multipartErrors", {
+			PartsLimitError,
+			FilesLimitError,
+			FieldsLimitError,
+			PrototypeViolationError,
+			InvalidMultipartContentTypeError,
+			RequestFileTooLargeError,
+			FileBufferNotFoundError
 		});
-		return value;
-	}
-	if (type === "password") return password({ message: prompt.message });
-	return input({
-		message: prompt.message,
-		default: prompt.default
-	});
-}
-/** Walk schema to find the env var name for a given dot path. */
-function findEnvVar(schema, dotPath) {
-	const parts = dotPath.split(".");
-	let current = schema;
-	for (const part of parts) {
-		if (current === null || current === void 0 || typeof current !== "object") return void 0;
-		const obj = current;
-		if (obj._tag === "optional") current = obj.shape[part];
-		else current = obj[part];
-	}
-	if (typeof current === "object" && current !== null && "_tag" in current) {
-		const field = current;
-		if (field._tag === "field") return field.options?.env;
+		fastify.addContentTypeParser("multipart/form-data", setMultipart);
+		fastify.decorateRequest(kMultipart, false);
+		fastify.decorateRequest(kMultipartHandler, handleMultipart);
+		fastify.decorateRequest(kSavedRequestFilesResult, null);
+		fastify.decorateRequest("parts", getMultipartIterator);
+		fastify.decorateRequest("isMultipart", isMultipart);
+		fastify.decorateRequest("tmpUploads", null);
+		fastify.decorateRequest("savedRequestFiles", null);
+		fastify.decorateRequest("file", getMultipartFile);
+		fastify.decorateRequest("files", getMultipartFiles);
+		fastify.decorateRequest("saveRequestFiles", saveRequestFiles);
+		fastify.decorateRequest("cleanRequestFiles", cleanRequestFiles);
+		fastify.addHook("onResponse", async (request) => {
+			await request.cleanRequestFiles();
+		});
+		function isMultipart() {
+			return this[kMultipart];
+		}
+		function handleMultipart(opts = {}) {
+			if (!this.isMultipart()) throw new InvalidMultipartContentTypeError();
+			this.log.debug("starting multipart parsing");
+			let values = [];
+			let pendingHandler = null;
+			const ch = (val) => {
+				if (pendingHandler) {
+					pendingHandler(val);
+					pendingHandler = null;
+				} else values.push(val);
+			};
+			const handle = (handler) => {
+				if (values.length > 0) {
+					const value = values[0];
+					values = values.slice(1);
+					handler(value);
+				} else pendingHandler = handler;
+			};
+			const parts = () => {
+				return new Promise((resolve, reject) => {
+					handle((val) => {
+						if (val instanceof Error) if (val.message === "Unexpected end of multipart data") resolve(null);
+						else reject(val);
+						else resolve(val);
+					});
+				});
+			};
+			const body = {};
+			let lastError = null;
+			let currentFile = null;
+			const request = this.raw;
+			const busboyOptions = deepmergeAll({ headers: request.headers }, options, opts);
+			this.log.trace({ busboyOptions }, "Providing options to busboy");
+			const bb = busboy(busboyOptions);
+			request.on("close", cleanup);
+			request.on("error", cleanup);
+			bb.on("field", onField).on("file", onFile).on("end", cleanup).on("finish", cleanup).on("close", cleanup).on("error", cleanup);
+			bb.on("partsLimit", function() {
+				const err = new PartsLimitError();
+				onError(err);
+				process.nextTick(() => cleanup(err));
+			});
+			bb.on("filesLimit", function() {
+				const err = new FilesLimitError();
+				onError(err);
+				process.nextTick(() => cleanup(err));
+			});
+			bb.on("fieldsLimit", function() {
+				const err = new FieldsLimitError();
+				onError(err);
+				process.nextTick(() => cleanup(err));
+			});
+			request.pipe(bb);
+			function onField(name, fieldValue, fieldnameTruncated, valueTruncated, encoding, contentType) {
+				if (name in Object.prototype) {
+					onError(new PrototypeViolationError());
+					return;
+				}
+				if (contentType.startsWith("application/json")) {
+					if (valueTruncated) {
+						onError(new InvalidJSONFieldError());
+						return;
+					}
+					try {
+						fieldValue = secureJSON.parse(fieldValue);
+						contentType = "application/json";
+					} catch {
+						onError(new InvalidJSONFieldError());
+						return;
+					}
+				}
+				const value = {
+					type: "field",
+					fieldname: name,
+					mimetype: contentType,
+					encoding,
+					value: fieldValue,
+					fieldnameTruncated,
+					valueTruncated,
+					fields: body
+				};
+				if (body[name] === void 0) body[name] = value;
+				else if (Array.isArray(body[name])) body[name].push(value);
+				else body[name] = [body[name], value];
+				ch(value);
+			}
+			function onFile(name, file, filename, encoding, mimetype) {
+				if (name in Object.prototype) {
+					streamToNull(file).catch(() => {});
+					onError(new PrototypeViolationError());
+					return;
+				}
+				const throwFileSizeLimit = typeof opts.throwFileSizeLimit === "boolean" ? opts.throwFileSizeLimit : defaultThrowFileSizeLimit;
+				const value = {
+					type: "file",
+					fieldname: name,
+					filename,
+					encoding,
+					mimetype,
+					file,
+					fields: body,
+					_buf: null,
+					async toBuffer() {
+						if (this._buf) return this._buf;
+						const fileChunks = [];
+						let err;
+						for await (const chunk of this.file) {
+							fileChunks.push(chunk);
+							if (throwFileSizeLimit && this.file.truncated) {
+								err = new RequestFileTooLargeError();
+								err.part = this;
+								onError(err);
+								fileChunks.length = 0;
+							}
+						}
+						if (err) throw err;
+						this._buf = Buffer.concat(fileChunks);
+						return this._buf;
+					}
+				};
+				file.on("error", function(err) {
+					if (err.message && err.message.includes("terminated early")) onError(err);
+				});
+				if (throwFileSizeLimit) file.on("limit", function() {
+					const err = new RequestFileTooLargeError();
+					err.part = value;
+					onError(err);
+				});
+				if (body[name] === void 0) body[name] = value;
+				else if (Array.isArray(body[name])) body[name].push(value);
+				else body[name] = [body[name], value];
+				currentFile = file;
+				ch(value);
+			}
+			function onError(err) {
+				lastError = err;
+				currentFile = null;
+			}
+			function cleanup(err) {
+				request.unpipe(bb);
+				if ((err || request.aborted) && currentFile) {
+					currentFile.destroy();
+					currentFile = null;
+				}
+				ch(err || lastError || null);
+			}
+			return parts;
+		}
+		async function saveRequestFiles(options) {
+			if (this[kSavedRequestFilesResult]) return this[kSavedRequestFilesResult];
+			let parts;
+			let values = {};
+			if (attachFieldsToBody === true || attachFieldsToBody === "keyValues") {
+				parts = this.body ? filesFromFields.call(this, this.body) : [];
+				values = this.body || {};
+			} else parts = this.parts(options);
+			this.savedRequestFiles = [];
+			const tmpdir = options?.tmpdir || os.tmpdir();
+			this.tmpUploads = [];
+			let i = 0;
+			for await (const part of parts) {
+				values = part.fields;
+				if (!part.file) continue;
+				const filepath = path.join(tmpdir, generateId() + path.extname(part.filename || "file" + i++));
+				const target = createWriteStream$1(filepath);
+				try {
+					this.tmpUploads.push(filepath);
+					await pump(part.file, target);
+					this.savedRequestFiles.push({
+						...part,
+						filepath
+					});
+				} catch (err) {
+					target.destroy();
+					await this.cleanRequestFiles();
+					this.log.error({ err }, "save request file");
+					throw err;
+				}
+			}
+			this[kSavedRequestFilesResult] = {
+				files: this.savedRequestFiles,
+				values
+			};
+			return this[kSavedRequestFilesResult];
+		}
+		function* filesFromFields(container) {
+			try {
+				const fields = Array.isArray(container) ? container : Object.values(container);
+				for (let i = 0; i < fields.length; ++i) {
+					const field = fields[i];
+					if (Array.isArray(field)) for (const subField of filesFromFields.call(this, field)) yield subField;
+					if (!field.file) continue;
+					if (!field._buf) throw new FileBufferNotFoundError();
+					field.file = Readable.from(field._buf);
+					yield field;
+				}
+			} catch (err) {
+				this.log.error({ err }, "save request file failed");
+				throw err;
+			}
+		}
+		async function cleanRequestFiles() {
+			if (!this.tmpUploads) return;
+			for (let i = 0; i < this.tmpUploads.length; ++i) {
+				const filepath = this.tmpUploads[i];
+				try {
+					await unlink(filepath);
+				} 				/* c8 ignore start */catch (error)  {
+					this.log.error(error, "Could not delete file");
+				}
+			}
+		}
+		async function getMultipartFile(options) {
+			const parts = this[kMultipartHandler](options);
+			let part;
+			while ((part = await parts()) != null) if (part.file) return part;
+		}
+		async function* getMultipartFiles(options) {
+			const parts = this[kMultipartHandler](options);
+			let part;
+			while ((part = await parts()) != null) if (part.file) yield part;
+		}
+		async function* getMultipartIterator(options) {
+			const parts = this[kMultipartHandler](options);
+			let part;
+			while ((part = await parts()) != null) yield part;
+		}
+		done();
 	}
-}
-function setNestedByDot(obj, dotPath, value) {
-	const parts = dotPath.split(".");
-	let current = obj;
-	for (let i = 0; i < parts.length - 1; i++) {
-		const key = parts[i];
-		if (key === void 0) continue;
-		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) current[key] = {};
-		current = current[key];
+	/**
+	* Adds a new type `isFile` to help @fastify/swagger generate the correct schema.
+	*/
+	function ajvFilePlugin(ajv) {
+		return ajv.addKeyword({
+			keyword: "isFile",
+			compile: (_schema, parent) => {
+				parent.type = "string";
+				parent.format = "binary";
+				delete parent.isFile;
+				return (field) => !!field.file;
+			},
+			error: { message: "should be a file" }
+		});
 	}
-	const lastKey = parts.at(-1);
-	if (lastKey !== void 0) current[lastKey] = value;
-}
-//#endregion
-//#region ../server/dist/app-C6y-ySN9.mjs
+	/**
+	* These export configurations enable JS and TS developers
+	* to consumer fastify in whatever way best suits their needs.
+	*/
+	module.exports = fp(fastifyMultipart, {
+		fastify: "5.x",
+		name: "@fastify/multipart"
+	});
+	module.exports.default = fastifyMultipart;
+	module.exports.fastifyMultipart = fastifyMultipart;
+	module.exports.ajvFilePlugin = ajvFilePlugin;
+})))(), 1);
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -8819,6 +12206,99 @@ async function adminTaskRoutes(app) {
 		return getTaskHealth(app.db, request.params.taskId);
 	});
 }
+const UPLOADS_DIR = join(DEFAULT_DATA_DIR$1, "uploads");
+const MAX_FILE_SIZE = 10 * 1024 * 1024;
+const ALLOWED_MIME_TYPES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp",
+	"image/svg+xml"
+]);
+function ensureUploadsDir() {
+	if (!existsSync(UPLOADS_DIR)) mkdirSync(UPLOADS_DIR, { recursive: true });
+}
+async function adminUploadRoutes(app) {
+	ensureUploadsDir();
+	/** POST /admin/uploads — upload a file, returns URL */
+	app.post("/", async (request, reply) => {
+		requireMember(request);
+		const data = await request.file();
+		if (!data) return reply.status(400).send({ error: "No file provided" });
+		const mimeType = data.mimetype;
+		if (!ALLOWED_MIME_TYPES.has(mimeType)) return reply.status(400).send({ error: `Unsupported file type: ${mimeType}. Allowed: ${[...ALLOWED_MIME_TYPES].join(", ")}` });
+		const ext = extname(data.filename) || mimeExtension(mimeType);
+		const uniqueName = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").slice(0, 14)}_${randomUUID().slice(0, 8)}${ext}`;
+		const filePath = join(UPLOADS_DIR, uniqueName);
+		let totalSize = 0;
+		const writeStream = createWriteStream(filePath);
+		try {
+			const fileStream = data.file;
+			for await (const chunk of fileStream) {
+				totalSize += chunk.length;
+				if (totalSize > MAX_FILE_SIZE) {
+					writeStream.destroy();
+					try {
+						unlinkSync(filePath);
+					} catch {}
+					return reply.status(400).send({ error: `File too large. Maximum size: ${MAX_FILE_SIZE / 1024 / 1024}MB` });
+				}
+				writeStream.write(chunk);
+			}
+			writeStream.end();
+			await new Promise((resolve, reject) => {
+				writeStream.on("finish", resolve);
+				writeStream.on("error", reject);
+			});
+		} catch (err) {
+			writeStream.destroy();
+			throw err;
+		}
+		const url = `/api/v1/uploads/${uniqueName}`;
+		return reply.status(201).send({
+			url,
+			filename: data.filename,
+			storedName: uniqueName,
+			mimeType,
+			size: totalSize
+		});
+	});
+}
+/** Public routes — GET uploaded files (URL contains random UUID, not guessable) */
+async function publicUploadRoutes(app) {
+	ensureUploadsDir();
+	/** GET /uploads/:filename — serve uploaded file without auth */
+	app.get("/:filename", async (request, reply) => {
+		const { filename } = request.params;
+		if (filename.includes("/") || filename.includes("..")) return reply.status(400).send({ error: "Invalid filename" });
+		const filePath = join(UPLOADS_DIR, filename);
+		if (!existsSync(filePath)) return reply.status(404).send({ error: "File not found" });
+		const contentType = extensionToMime(extname(filename).toLowerCase()) ?? "application/octet-stream";
+		const stream = createReadStream(filePath);
+		return reply.type(contentType).send(stream);
+	});
+}
+function mimeExtension(mime) {
+	switch (mime) {
+		case "image/png": return ".png";
+		case "image/jpeg": return ".jpg";
+		case "image/gif": return ".gif";
+		case "image/webp": return ".webp";
+		case "image/svg+xml": return ".svg";
+		default: return "";
+	}
+}
+function extensionToMime(ext) {
+	switch (ext) {
+		case ".png": return "image/png";
+		case ".jpg":
+		case ".jpeg": return "image/jpeg";
+		case ".gif": return "image/gif";
+		case ".webp": return "image/webp";
+		case ".svg": return "image/svg+xml";
+		default: return null;
+	}
+}
 async function loadVisibleAgentIds(db, organizationId, memberId) {
 	const rows = await db.select({ id: agents.uuid }).from(agents).where(and(eq(agents.organizationId, organizationId), ne(agents.status, AGENT_STATUSES.DELETED), or(eq(agents.visibility, AGENT_VISIBILITY.ORGANIZATION), eq(agents.managerId, memberId))));
 	return new Set(rows.map((r) => r.id));
@@ -9541,6 +13021,11 @@ function clientWsRoutes(notifier, instanceId) {
 						clearTimeout(authTimeout);
 						scheduleAuthExpiry(claims.exp);
 						socket.send(JSON.stringify({ type: "auth:ok" }));
+						socket.send(JSON.stringify({
+							type: "server:welcome",
+							serverCommandVersion: app.commandVersion,
+							serverTimeMs: Date.now()
+						}));
 					} catch (err) {
 						const message = err instanceof Error ? err.message : "auth failure";
 						socket.send(JSON.stringify({
@@ -11898,6 +15383,21 @@ function createPulseAggregator(options) {
 		ingest
 	};
 }
+/**
+* Resolve the Command-package version advertised to clients. Prefers the
+* value the Command CLI explicitly injected; otherwise falls back to the
+* server workspace's own package.json (dev mode, `pnpm --filter … dev`).
+* Returning a string (rather than undefined) keeps the welcome frame well-
+* formed — the client treats the value advisorily.
+*/
+function resolveCommandVersion(injected) {
+	if (injected && injected.trim().length > 0) return injected;
+	try {
+		const pkg = createRequire(import.meta.url)("../package.json");
+		if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+	} catch {}
+	return "0.0.0";
+}
 async function buildApp(config) {
 	applyLoggerConfig({
 		level: config.observability.logging.level,
@@ -11911,9 +15411,13 @@ async function buildApp(config) {
 	const db = connectDatabase(config.database.url);
 	app.decorate("db", db);
 	app.decorate("config", config);
+	const commandVersion = resolveCommandVersion(config.commandVersion);
+	app.decorate("commandVersion", commandVersion);
+	app.log.info({ commandVersion }, "Hub server advertising command version");
 	const listenClient = postgres(config.database.url, { max: 1 });
 	const notifier = createNotifier(listenClient);
 	await app.register(websocket);
+	await app.register(import_multipart.default, { limits: { fileSize: 10 * 1024 * 1024 } });
 	const corsOrigin = config.cors?.origin;
 	const isDev = process.env.NODE_ENV !== "production";
 	await app.register(cors, {
@@ -11952,6 +15456,7 @@ async function buildApp(config) {
 		await api.register(authRoutes, { prefix: "/auth" });
 		await api.register(contextTreeInfoRoutes, { prefix: "/context-tree" });
 		await api.register(bootstrapConfigRoutes, { prefix: "/bootstrap" });
+		await api.register(publicUploadRoutes, { prefix: "/uploads" });
 		await api.register(async (adminApp) => {
 			adminApp.addHook("onRequest", memberAuth);
 			await adminApp.register(adminAgentRoutes);
@@ -11998,6 +15503,10 @@ async function buildApp(config) {
 			adminApp.addHook("onRequest", memberAuth);
 			await adminApp.register(adminChatRoutes);
 		}, { prefix: "/admin/chats" });
+		await api.register(async (adminApp) => {
+			adminApp.addHook("onRequest", memberAuth);
+			await adminApp.register(adminUploadRoutes);
+		}, { prefix: "/admin/uploads" });
 		await api.register(async (adminApp) => {
 			adminApp.addHook("onRequest", memberAuth);
 			await adminApp.register(adminClientRoutes);
@@ -12101,6 +15610,10 @@ async function buildApp(config) {
 	return app;
 }
 //#endregion
+//#region src/core/version.ts
+const pkg = createRequire(import.meta.url)("../../package.json");
+const COMMAND_VERSION = typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "0.0.0";
+//#endregion
 //#region src/core/server.ts
 /**
 * Full server start orchestration:
@@ -12113,7 +15626,7 @@ async function buildApp(config) {
 * 7. Start Fastify server
 */
 async function startServer(options) {
-	process.stderr.write("\n  First Tree Hub v0.1.0\n\n");
+	process.stderr.write(`\n  First Tree Hub v${COMMAND_VERSION}\n\n`);
 	const cliArgs = {};
 	if (options.port !== void 0) cliArgs.server = { port: options.port };
 	if (options.host !== void 0) cliArgs.server = {
@@ -12152,7 +15665,8 @@ async function startServer(options) {
 	const config = {
 		...serverConfig,
 		webDistPath: webDistPath ?? void 0,
-		instanceId: `srv_${randomUUID().slice(0, 8)}`
+		instanceId: `srv_${randomUUID().slice(0, 8)}`,
+		commandVersion: COMMAND_VERSION
 	};
 	const { initTelemetry, shutdownTelemetry } = await import("./observability-Xi-sEZI7.mjs");
 	await initTelemetry(serverConfig.observability.tracing, config.instanceId);
@@ -12176,419 +15690,208 @@ async function startServer(options) {
 	status("Server", `running at http://${config.server.host}:${config.server.port}`);
 	blank();
 	process.stderr.write("  Open the URL above in your browser to get started.\n");
-	process.stderr.write("  Press Ctrl+C to stop.\n\n");
-}
-/**
-* Resolve web dist path.
-* 1. npm install: embedded at dist/web/ (relative to the built CLI)
-* 2. Monorepo dev: resolved from @first-tree-hub/web package (builds if needed)
-*/
-function resolveWebDist() {
-	const embeddedPath = join(dirname(fileURLToPath(import.meta.url)), "..", "web");
-	if (existsSync(join(embeddedPath, "index.html"))) return embeddedPath;
-	try {
-		const webDir = dirname(fileURLToPath(import.meta.resolve("@first-tree-hub/web/package.json")));
-		const distPath = join(webDir, "dist");
-		const indexPath = join(distPath, "index.html");
-		if (existsSync(indexPath)) return distPath;
-		status("Web", "building...");
-		execSync("pnpm --filter @first-tree-hub/web build", {
-			stdio: [
-				"ignore",
-				"ignore",
-				"pipe"
-			],
-			cwd: join(webDir, "../..")
-		});
-		if (existsSync(indexPath)) return distPath;
-	} catch {}
-}
-//#endregion
-//#region src/core/service-install.ts
-/**
-* Run a subprocess capturing stderr so failures surface a meaningful error
-* instead of Node's opaque "Command failed". Used for launchctl/systemctl —
-* anywhere the stderr message is diagnostically crucial.
-*/
-function runCapture(program, args, timeoutMs) {
-	const res = spawnSync(program, args, {
-		encoding: "utf-8",
-		timeout: timeoutMs,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	if (res.status === 0) return { ok: true };
-	return {
-		ok: false,
-		stderr: (res.stderr ?? "").trim(),
-		code: res.status
-	};
-}
-function sleepSync(ms) {
-	const shared = new Int32Array(new SharedArrayBuffer(4));
-	Atomics.wait(shared, 0, 0, ms);
-}
-const LAUNCHD_LABEL = "dev.first-tree-hub.client";
-const SYSTEMD_UNIT = "first-tree-hub-client.service";
-const LOG_DIR = join(DEFAULT_HOME_DIR$1, "logs");
-function whichBin(name) {
-	try {
-		return execFileSync(process.platform === "win32" ? "where" : "which", [name], {
-			encoding: "utf-8",
-			timeout: 3e3
-		}).split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0] ?? null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Resolve how the service should launch the CLI.
-*
-* Prefers the installed `first-tree-hub` bin on PATH (usually a shim under
-* /usr/local/bin or ~/.npm-global/bin). Falls back to invoking the current
-* Node interpreter against the running script (handles `pnpm dev`, tsx, and
-* dev-only global installs).
-*/
-function resolveCliInvocation() {
-	const bin = whichBin("first-tree-hub");
-	if (bin && isAbsolute(bin)) try {
-		return {
-			kind: "bin",
-			program: realpathSync(bin)
-		};
-	} catch {
-		return {
-			kind: "bin",
-			program: bin
-		};
-	}
-	const script = process.argv[1];
-	if (!script) throw new Error("Cannot resolve CLI entry point (process.argv[1] is empty).");
-	const scriptAbs = isAbsolute(script) ? script : join(process.cwd(), script);
-	return {
-		kind: "node",
-		program: process.execPath,
-		args: [scriptAbs]
-	};
-}
-function ensureLogDir() {
-	mkdirSync(LOG_DIR, {
-		recursive: true,
-		mode: 448
-	});
-}
-function launchdPlistPath() {
-	return join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-}
-function renderPlist(invocation) {
-	const argsXml = (invocation.kind === "bin" ? [
-		invocation.program,
-		"client",
-		"start",
-		"--no-interactive"
-	] : [
-		invocation.program,
-		...invocation.args,
-		"client",
-		"start",
-		"--no-interactive"
-	]).map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
-	const outLog = join(LOG_DIR, "client.out.log");
-	const errLog = join(LOG_DIR, "client.err.log");
-	return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTD/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${LAUNCHD_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-${argsXml}
-  </array>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>PATH</key>
-    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
-  </dict>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <dict>
-    <key>SuccessfulExit</key>
-    <false/>
-  </dict>
-  <key>ThrottleInterval</key>
-  <integer>10</integer>
-  <key>StandardOutPath</key>
-  <string>${escapeXml(outLog)}</string>
-  <key>StandardErrorPath</key>
-  <string>${escapeXml(errLog)}</string>
-</dict>
-</plist>
-`;
-}
-function escapeXml(value) {
-	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function launchctlDomainTarget() {
-	return `gui/${userInfo().uid}`;
-}
-function launchdState() {
-	if (!existsSync(launchdPlistPath())) return { state: "not-installed" };
-	const res = spawnSync("launchctl", ["print", `${launchctlDomainTarget()}/${LAUNCHD_LABEL}`], {
-		encoding: "utf-8",
-		timeout: 5e3,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	if (res.status !== 0) return {
-		state: "inactive",
-		detail: "plist present but not loaded"
-	};
-	const out = res.stdout ?? "";
-	const stateLine = out.split(/\r?\n/).find((l) => l.trim().startsWith("state ="));
-	const pidLine = out.split(/\r?\n/).find((l) => l.trim().startsWith("pid ="));
-	if (stateLine?.includes("running")) {
-		const pid = pidLine?.split("=")[1]?.trim();
-		return {
-			state: "active",
-			detail: pid ? `pid ${pid}` : "running"
-		};
-	}
-	return {
-		state: "inactive",
-		detail: stateLine?.trim() ?? "loaded"
-	};
+	process.stderr.write("  Press Ctrl+C to stop.\n\n");
 }
 /**
-* Poll `launchctl print` until the label disappears, confirming launchd has
-* finished the async eviction kicked off by `bootout`. Required because
-* `bootout` returns before the actual unload completes when the service has
-* active WebSocket connections — a follow-up `bootstrap` against a still-
-* registered label fails with `Bootstrap failed: 5: Input/output error`.
+* Resolve web dist path.
+* 1. npm install: embedded at dist/web/ (relative to the built CLI)
+* 2. Monorepo dev: resolved from @first-tree-hub/web package (builds if needed)
 */
-function waitForLabelEvicted(target, label, timeoutMs) {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		if (spawnSync("launchctl", ["print", `${target}/${label}`], {
-			encoding: "utf-8",
-			timeout: 2e3,
+function resolveWebDist() {
+	const embeddedPath = join(dirname(fileURLToPath(import.meta.url)), "..", "web");
+	if (existsSync(join(embeddedPath, "index.html"))) return embeddedPath;
+	try {
+		const webDir = dirname(fileURLToPath(import.meta.resolve("@first-tree-hub/web/package.json")));
+		const distPath = join(webDir, "dist");
+		const indexPath = join(distPath, "index.html");
+		if (existsSync(indexPath)) return distPath;
+		status("Web", "building...");
+		execSync("pnpm --filter @first-tree-hub/web build", {
 			stdio: [
 				"ignore",
 				"ignore",
 				"pipe"
-			]
-		}).status !== 0) return true;
-		sleepSync(200);
-	}
-	return false;
-}
-function installLaunchd() {
-	const invocation = resolveCliInvocation();
-	ensureLogDir();
-	const plistPath = launchdPlistPath();
-	mkdirSync(dirname(plistPath), { recursive: true });
-	writeFileSync(plistPath, renderPlist(invocation), { mode: 420 });
-	const target = launchctlDomainTarget();
-	const bootoutRes = runCapture("launchctl", ["bootout", `${target}/${LAUNCHD_LABEL}`], 15e3);
-	if (!bootoutRes.ok) {
-		if (!/not find|no such|not loaded/i.test(bootoutRes.stderr)) process.stderr.write(`    warning: launchctl bootout: ${bootoutRes.stderr || `exit ${bootoutRes.code ?? "unknown"}`}\n`);
-	}
-	waitForLabelEvicted(target, LAUNCHD_LABEL, 1e4);
-	let lastBootstrapErr = null;
-	for (let attempt = 1; attempt <= 2; attempt++) {
-		const res = runCapture("launchctl", [
-			"bootstrap",
-			target,
-			plistPath
-		], 1e4);
-		if (res.ok) {
-			lastBootstrapErr = null;
-			break;
-		}
-		lastBootstrapErr = res;
-		if (attempt < 2) sleepSync(1e3);
-	}
-	if (lastBootstrapErr) throw new Error(`launchctl bootstrap failed: ${lastBootstrapErr.stderr || `exit ${lastBootstrapErr.code ?? "unknown"}`}\n    Command: launchctl bootstrap ${target} ${plistPath}\n    Recovery: \`launchctl bootout ${target}/${LAUNCHD_LABEL}\` then \`first-tree-hub service install\`.`);
-	const enableRes = runCapture("launchctl", ["enable", `${target}/${LAUNCHD_LABEL}`], 5e3);
-	if (!enableRes.ok) process.stderr.write(`    warning: launchctl enable: ${enableRes.stderr || `exit ${enableRes.code ?? "unknown"}`}\n`);
-	const { state, detail } = launchdState();
-	return {
-		platform: "launchd",
-		label: LAUNCHD_LABEL,
-		unitPath: plistPath,
-		logDir: LOG_DIR,
-		state,
-		detail
-	};
-}
-function uninstallLaunchd() {
-	const plistPath = launchdPlistPath();
-	const res = runCapture("launchctl", ["bootout", `${launchctlDomainTarget()}/${LAUNCHD_LABEL}`], 15e3);
-	if (!res.ok && !/not find|no such|not loaded/i.test(res.stderr)) process.stderr.write(`    warning: bootout during uninstall: ${res.stderr || `exit ${res.code ?? "unknown"}`}\n`);
-	if (existsSync(plistPath)) rmSync(plistPath);
-	return {
-		platform: "launchd",
-		label: LAUNCHD_LABEL,
-		unitPath: plistPath,
-		logDir: LOG_DIR,
-		state: "not-installed"
-	};
-}
-function systemdUnitPath() {
-	return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "systemd", "user", SYSTEMD_UNIT);
+			],
+			cwd: join(webDir, "../..")
+		});
+		if (existsSync(indexPath)) return distPath;
+	} catch {}
 }
-function renderSystemdUnit(invocation) {
-	return `[Unit]
-Description=First Tree Hub Client
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${invocation.kind === "bin" ? `${shellQuote(invocation.program)} client start --no-interactive` : `${shellQuote(invocation.program)} ${invocation.args.map(shellQuote).join(" ")} client start --no-interactive`}
-Restart=always
-RestartSec=10
-StandardOutput=append:${join(LOG_DIR, "client.out.log")}
-StandardError=append:${join(LOG_DIR, "client.err.log")}
-Environment=PATH=/usr/local/bin:/usr/bin:/bin
-
-[Install]
-WantedBy=default.target
-`;
+//#endregion
+//#region src/core/update.ts
+const PACKAGE_NAME = "@agent-team-foundation/first-tree-hub";
+/**
+* Pick the `npm` binary to invoke for self-update. Background service units
+* hard-code a minimal PATH (/usr/local/bin, /opt/homebrew/bin, /usr/bin,
+* /bin) that misses nvm / asdf / Volta toolchain directories — the client
+* launches fine from an absolute path resolved at install time, but a plain
+* `spawn("npm")` then ENOENTs. Node and npm always ship side-by-side, so
+* `dirname(execPath)/npm` is the most reliable fallback across those
+* managers; if the sibling is missing (e.g. corporate custom layout) we
+* fall back to PATH lookup.
+*/
+function resolveNpmCommand() {
+	const binName = process.platform === "win32" ? "npm.cmd" : "npm";
+	const sibling = join(dirname(process.execPath), binName);
+	if (existsSync(sibling)) return sibling;
+	return "npm";
 }
-function shellQuote(value) {
-	if (/^[A-Za-z0-9_\-./:=]+$/.test(value)) return value;
-	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+/**
+* Detect how the CLI was launched. Used by the update path to decide whether
+* `npm install -g <pkg>@latest` makes sense.
+*
+*  - `"global"`: launched from an `npm install -g` install. The self-update
+*    reinstalls the same package at `@latest`.
+*  - `"source"`: launched from inside a git checkout (dev / monorepo). Update
+*    is a no-op; operator should `git pull`.
+*  - `"npx"` (fallback): any other path (e.g. one-shot `npx`, pnpm dlx). Auto
+*    update is not safe; log a hint and skip.
+*/
+function detectInstallMode(argv1 = process.argv[1] ?? "") {
+	if (!argv1) return "npx";
+	let dir = dirname(resolve(argv1));
+	for (let i = 0; i < 10; i++) {
+		if (existsSync(resolve(dir, ".git"))) return "source";
+		const pkgPath = resolve(dir, "package.json");
+		if (existsSync(pkgPath)) try {
+			if (JSON.parse(readFileSync(pkgPath, "utf8")).name === PACKAGE_NAME) {
+				if (/\/(?:_npx|\.npm\/_npx)\//.test(dir)) return "npx";
+				return "global";
+			}
+		} catch {}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return "npx";
 }
-function systemdState() {
-	if (!existsSync(systemdUnitPath())) return { state: "not-installed" };
-	const res = spawnSync("systemctl", [
-		"--user",
-		"is-active",
-		SYSTEMD_UNIT
-	], {
-		encoding: "utf-8",
-		timeout: 5e3,
-		stdio: [
+/**
+* Install `<pkg>@latest` globally. Returns after the child exits. Does not
+* exit the parent process — callers are expected to handle that (so the
+* UpdateManager can attempt the restart itself while this function remains
+* side-effect-scoped).
+*/
+async function installGlobalLatest() {
+	return new Promise((resolvePromise) => {
+		const child = spawn(resolveNpmCommand(), [
+			"install",
+			"-g",
+			`${PACKAGE_NAME}@latest`
+		], { stdio: [
 			"ignore",
 			"pipe",
 			"pipe"
-		]
+		] });
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+		child.stderr.on("data", (chunk) => {
+			stderrChunks.push(chunk);
+			process.stderr.write(chunk);
+		});
+		child.on("error", (err) => {
+			resolvePromise({
+				ok: false,
+				mode: "global",
+				reason: err instanceof Error ? err.message : String(err)
+			});
+		});
+		child.on("exit", (code) => {
+			if (code === 0) resolvePromise({
+				ok: true,
+				mode: "global",
+				installedVersion: parseInstalledVersion(Buffer.concat(stdoutChunks).toString("utf8"))
+			});
+			else {
+				const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+				resolvePromise({
+					ok: false,
+					mode: "global",
+					reason: `npm install -g exited with code ${code}${stderr ? `: ${stderr.split("\n").slice(-3).join(" | ")}` : ""}`
+				});
+			}
+		});
 	});
-	const out = (res.stdout ?? "").trim();
-	if (res.status === 0 && out === "active") return {
-		state: "active",
-		detail: "running"
-	};
-	return {
-		state: "inactive",
-		detail: out || "unit present but not active"
-	};
-}
-function installSystemd() {
-	const invocation = resolveCliInvocation();
-	ensureLogDir();
-	const unitPath = systemdUnitPath();
-	mkdirSync(dirname(unitPath), { recursive: true });
-	writeFileSync(unitPath, renderSystemdUnit(invocation), { mode: 420 });
-	const reloadRes = runCapture("systemctl", ["--user", "daemon-reload"], 5e3);
-	if (!reloadRes.ok) throw new Error(`systemctl --user daemon-reload failed: ${reloadRes.stderr || `exit ${reloadRes.code ?? "unknown"}`}`);
-	const enableRes = runCapture("systemctl", [
-		"--user",
-		"enable",
-		"--now",
-		SYSTEMD_UNIT
-	], 1e4);
-	if (!enableRes.ok) throw new Error(`systemctl --user enable --now ${SYSTEMD_UNIT} failed: ${enableRes.stderr || `exit ${enableRes.code ?? "unknown"}`}\n    Recovery: \`systemctl --user stop ${SYSTEMD_UNIT}\` then \`first-tree-hub service install\`.`);
-	const { state, detail } = systemdState();
-	return {
-		platform: "systemd",
-		label: SYSTEMD_UNIT,
-		unitPath,
-		logDir: LOG_DIR,
-		state,
-		detail
-	};
-}
-function uninstallSystemd() {
-	const unitPath = systemdUnitPath();
-	const disableRes = runCapture("systemctl", [
-		"--user",
-		"disable",
-		"--now",
-		SYSTEMD_UNIT
-	], 1e4);
-	if (!disableRes.ok && !/not found|no such|not loaded/i.test(disableRes.stderr)) process.stderr.write(`    warning: systemctl disable during uninstall: ${disableRes.stderr || `exit ${disableRes.code ?? "unknown"}`}\n`);
-	if (existsSync(unitPath)) rmSync(unitPath);
-	const reloadRes = runCapture("systemctl", ["--user", "daemon-reload"], 5e3);
-	if (!reloadRes.ok) process.stderr.write(`    warning: systemctl daemon-reload during uninstall: ${reloadRes.stderr || `exit ${reloadRes.code ?? "unknown"}`}\n`);
-	return {
-		platform: "systemd",
-		label: SYSTEMD_UNIT,
-		unitPath,
-		logDir: LOG_DIR,
-		state: "not-installed"
-	};
-}
-/** Is background-service install supported on the current platform? */
-function isServiceSupported() {
-	return process.platform === "darwin" || process.platform === "linux";
 }
 /**
-* Install the background service for the current platform.
-*
-* @throws {Error} if the platform is not supported or the service manager fails.
+* Best-effort extraction of the version npm reported as installed. npm's
+* stdout lines look like `+ @agent-team-foundation/first-tree-hub@0.9.2`.
+* Returns null if nothing matches — callers treat null as "install succeeded
+* but version unknown".
 */
-function installClientService() {
-	if (process.platform === "darwin") return installLaunchd();
-	if (process.platform === "linux") return installSystemd();
-	throw new Error(`Background service install is not supported on ${process.platform}. Run \`first-tree-hub client start\` manually to keep the computer online.`);
-}
-/** Report the current service state without modifying anything. */
-function getClientServiceStatus() {
-	if (process.platform === "darwin") {
-		const { state, detail } = launchdState();
-		return {
-			platform: "launchd",
-			label: LAUNCHD_LABEL,
-			unitPath: launchdPlistPath(),
-			logDir: LOG_DIR,
-			state,
-			detail
-		};
-	}
-	if (process.platform === "linux") {
-		const { state, detail } = systemdState();
-		return {
-			platform: "systemd",
-			label: SYSTEMD_UNIT,
-			unitPath: systemdUnitPath(),
-			logDir: LOG_DIR,
-			state,
-			detail
-		};
+function parseInstalledVersion(stdout) {
+	const match = new RegExp(`${escapeForRegex(PACKAGE_NAME)}@(\\S+)`).exec(stdout);
+	if (!match?.[1]) return null;
+	const cleaned = match[1].replace(/[,\s)]+$/, "");
+	return semver.valid(cleaned) ?? cleaned;
+}
+function escapeForRegex(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Interactive update prompt. Defaults to N on timeout. */
+const promptUpdate = async ({ currentVersion, targetVersion, timeoutSeconds }) => {
+	const message = `A newer First Tree Hub client is available.\n  You: ${currentVersion}\n  Server bundled with: ${targetVersion}\n  Will install: latest on npm (>= ${targetVersion})\n  Updating will restart the client and briefly interrupt any active sessions.\n  Update now?`;
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutSeconds * 1e3);
+		try {
+			return await confirm({
+				message,
+				default: false
+			}, { signal: controller.signal });
+		} finally {
+			clearTimeout(timer);
+		}
+	} catch {
+		return false;
 	}
-	return {
-		platform: "unsupported",
-		label: "",
-		unitPath: "",
-		logDir: LOG_DIR,
-		state: "not-installed",
-		detail: `platform ${process.platform} not supported`
+};
+/**
+* Update prompt that always declines. Wired in when the operator passes
+* `--no-interactive` — the UpdateManager will log the drift and move on
+* instead of blocking on a TTY confirm.
+*/
+const declineUpdate = async () => false;
+/**
+* Build the command-layer `executeUpdate` callback.
+*
+* `managed=true` means a process supervisor (launchd / systemd / Docker
+* `restart`) is expected to relaunch us after `process.exit` — the callback
+* installs the new bits and exits with `SELF_RESTART_EXIT_CODE` so the
+* relaunch picks up the new binary.
+*
+* `managed=false` means the process is running standalone (e.g. manual
+* `client start`, `client connect --no-service`, CI without a supervisor).
+* Exiting in that mode would leave the client offline until an operator
+* noticed — so the callback instead prints a restart hint, returns
+* `{ installed: true }`, and the UpdateManager stops retrying until the
+* operator restarts manually.
+*/
+function createExecuteUpdate({ managed }) {
+	return async () => {
+		const mode = detectInstallMode();
+		if (mode === "source") {
+			process.stderr.write("  [update] Running from source checkout — self-update skipped. Use `git pull` instead.\n");
+			return { installed: false };
+		}
+		if (mode === "npx") {
+			process.stderr.write("  [update] Cannot self-update — not launched from a global npm install.\n  Run `npm i -g @agent-team-foundation/first-tree-hub` manually.\n");
+			return { installed: false };
+		}
+		process.stderr.write("  [update] Running `npm install -g @agent-team-foundation/first-tree-hub@latest`...\n");
+		const result = await installGlobalLatest();
+		if (!result.ok) {
+			process.stderr.write(`  [update] Install failed: ${result.reason}\n`);
+			return { installed: false };
+		}
+		const installed = result.installedVersion ?? "latest";
+		if (managed) {
+			process.stderr.write(`  [update] Installed ${installed}. Restarting (exit 75).\n`);
+			process.exit(75);
+		}
+		process.stderr.write(`  [update] Installed ${installed}. Restart the client manually (Ctrl+C then \`first-tree-hub client start\`) to pick up the new version.\n`);
+		return { installed: true };
 	};
 }
-/** Uninstall the background service. No-op if not installed. */
-function uninstallClientService() {
-	if (process.platform === "darwin") return uninstallLaunchd();
-	if (process.platform === "linux") return uninstallSystemd();
-	return getClientServiceStatus();
-}
 //#endregion
-export { stopPostgres as A, checkServerReachable as C, status as D, blank as E, SdkError as F, SessionRegistry as I, cleanWorkspaces as L, createOwner as M, hasUser as N, ensurePostgres as O, FirstTreeHubSDK as P, applyClientLoggerConfig as R, checkServerHealth as S, printResults as T, checkClientConfig as _, uninstallClientService as a, checkNodeVersion as b, promptAddAgent as c, loadOnboardState as d, onboardCheck as f, checkAgentConfigs as g, runMigrations as h, resolveCliInvocation as i, ClientRuntime as j, isDockerAvailable as k, promptMissingFields as l, saveOnboardState as m, installClientService as n, startServer as o, onboardCreate as p, isServiceSupported as r, isInteractive as s, getClientServiceStatus as t, formatCheckReport as u, checkDatabase as v, checkWebSocket as w, checkServerConfig as x, checkDocker as y };
+export { printResults as A, SdkError as B, checkDatabase as C, checkServerHealth as D, checkServerConfig as E, stopPostgres as F, cleanWorkspaces as H, ClientRuntime as I, createOwner as L, status as M, ensurePostgres as N, checkServerReachable as O, isDockerAvailable as P, hasUser as R, checkClientConfig as S, checkNodeVersion as T, applyClientLoggerConfig as U, SessionRegistry as V, isServiceSupported as _, COMMAND_VERSION as a, runMigrations as b, promptMissingFields as c, onboardCheck as d, onboardCreate as f, installClientService as g, getClientServiceStatus as h, startServer as i, blank as j, checkWebSocket as k, formatCheckReport as l, runHomeMigration as m, declineUpdate as n, isInteractive as o, saveOnboardState as p, promptUpdate as r, promptAddAgent as s, createExecuteUpdate as t, loadOnboardState as u, resolveCliInvocation as v, checkDocker as w, checkAgentConfigs as x, uninstallClientService as y, FirstTreeHubSDK as z };