@agent-team-foundation/first-tree-hub 0.9.3 → 0.9.6

package/dist/{core-Y7M3d2aZ.mjs → core-USyOOh7y.mjs}

@@ -1,19 +1,20 @@
-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 { m as __toESM } from "./esm-CYu4tXXn.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$1, t as adapterAttrs, u as observabilityPlugin, v as withWsMessageSpan, y as FIRST_TREE_HUB_ATTR } from "./observability-DV_fQKqV-CuLWzBxQ.mjs";
+import { s as formatPrettyEntry$1, t as LOG_LEVELS$1, u as parseLogLevel$1 } from "./logger-core-BTmvdflj-DhdipBkV.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-DWifXj9b.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-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 { dirname, isAbsolute, join, resolve } from "node:path";
 import { Writable } from "node:stream";
-import { stringify } from "yaml";
-import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { homedir, hostname, platform, userInfo } from "node:os";
 import { EventEmitter } from "node:events";
+import { closeSync, copyFileSync, createReadStream, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, unwatchFile, watch, watchFile, writeFileSync, writeSync } from "node:fs";
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import WebSocket from "ws";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { execFileSync, execSync, spawn, spawnSync } from "node:child_process";
+import { stringify } from "yaml";
 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";
@@ -30,7 +31,8 @@ import Fastify from "fastify";
 import { bigserial, boolean, index, integer, jsonb, pgTable, primaryKey, serial, text, timestamp, unique, uniqueIndex } from "drizzle-orm/pg-core";
 import { SignJWT, jwtVerify } from "jose";
 import { Client, EventDispatcher, LoggerLevel, WSClient } from "@larksuiteoapi/node-sdk";
-//#region ../client/dist/observability-BUvHY6T-.mjs
+import { createInterface } from "node:readline";
+//#region ../client/dist/observability-B4kO005X.mjs
 var import_pino = /* @__PURE__ */ __toESM(require_pino(), 1);
 /**
 * Logger core — format / level primitives shared between server and client.
@@ -97,6 +99,39 @@ const SKIP_KEYS = new Set([
 	"hostname",
 	"v"
 ]);
+/**
+* Pino `redact.paths` entries applied to every root logger in Hub. Keeps the
+* list short on purpose — pino's redact walks each path on every log call, so
+* we target obvious sensitive field names plus a narrow set of nested forms
+* (`*.foo` matches a single nesting level in pino v9).
+*
+* Values matching these paths are replaced with the censor string `[REDACTED]`.
+*/
+const LOG_REDACT_PATHS = [
+	"password",
+	"*.password",
+	"token",
+	"*.token",
+	"accessToken",
+	"*.accessToken",
+	"refreshToken",
+	"*.refreshToken",
+	"jwt",
+	"*.jwt",
+	"secret",
+	"*.secret",
+	"apiKey",
+	"*.apiKey",
+	"api_key",
+	"*.api_key",
+	"credentials",
+	"*.credentials",
+	"authorization",
+	"*.authorization",
+	"*.headers.cookie",
+	"*.headers.authorization"
+];
+const LOG_REDACT_CENSOR = "[REDACTED]";
 function formatPrettyEntry(json) {
 	const obj = JSON.parse(json);
 	const level = obj.level;
@@ -123,42 +158,146 @@ function formatLocalTime() {
 	return `${d.toLocaleDateString("sv-SE")} ${d.toLocaleTimeString("en-GB", { hour12: false })}`;
 }
 function createLoggerOutputStream(options) {
+	const getDest = options.getDestination ?? (() => process.stderr);
 	return new Writable({ write(chunk, _, callback) {
 		const text = chunk.toString();
+		const dest = getDest();
 		try {
-			if (options.getFormat() === "pretty") process.stdout.write(formatPrettyEntry(text));
-			else process.stdout.write(text);
+			if (options.getFormat() === "pretty") dest.write(formatPrettyEntry(text));
+			else dest.write(text);
 			if (options.onJsonEntry) try {
 				const obj = JSON.parse(text);
 				options.onJsonEntry(obj);
 			} catch {}
 		} catch {
-			process.stdout.write(text);
+			dest.write(text);
 		}
 		callback();
 	} });
 }
+var RotatingFileStream = class extends Writable {
+	size;
+	fd;
+	path;
+	maxBytes;
+	maxFiles;
+	constructor(options) {
+		super();
+		this.path = options.path;
+		this.maxBytes = options.maxBytes;
+		this.maxFiles = Math.max(1, options.maxFiles);
+		mkdirSync(dirname(this.path), {
+			recursive: true,
+			mode: 448
+		});
+		try {
+			this.size = statSync(this.path).size;
+		} catch {
+			this.size = 0;
+		}
+		this.fd = openSync(this.path, "a", 384);
+	}
+	_write(chunk, _enc, callback) {
+		try {
+			const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			writeSync(this.fd, buf);
+			this.size += buf.length;
+			if (this.size >= this.maxBytes) this.rotate();
+			callback();
+		} catch (err) {
+			callback(err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	_final(callback) {
+		try {
+			closeSync(this.fd);
+			callback();
+		} catch (err) {
+			callback(err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	rotate() {
+		closeSync(this.fd);
+		for (let i = this.maxFiles - 1; i >= 1; i--) renameIfExists(`${this.path}.${i}`, `${this.path}.${i + 1}`);
+		unlinkIfExists(`${this.path}.1`);
+		renameSync(this.path, `${this.path}.1`);
+		this.fd = openSync(this.path, "a", 384);
+		this.size = 0;
+	}
+};
+function isNotFound(err) {
+	return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+function renameIfExists(from, to) {
+	try {
+		unlinkIfExists(to);
+		renameSync(from, to);
+	} catch (err) {
+		if (!isNotFound(err)) throw err;
+	}
+}
+function unlinkIfExists(path) {
+	try {
+		unlinkSync(path);
+	} catch (err) {
+		if (!isNotFound(err)) throw err;
+	}
+}
+/** Rotation defaults for the background service log file. */
+const SERVICE_LOG_MAX_BYTES = 10 * 1024 * 1024;
+const SERVICE_LOG_MAX_FILES = 7;
 /**
 * Client-side logger. Same pretty / NDJSON formats as the server logger, but
 * intentionally lightweight — the client is deployed to agent user machines,
 * so we skip tracing, context propagation, and error sinks.
 */
 const initialLevel = parseLogLevel(process.env.FIRST_TREE_HUB_LOG_LEVEL);
+const initialPinoLevel = process.env.NODE_ENV === "test" && !process.env.FIRST_TREE_HUB_LOG_LEVEL ? "silent" : initialLevel.level;
 let _format = process.env.NODE_ENV === "production" ? "json" : "pretty";
-let _level = initialLevel.level;
+let _destination = process.stderr;
+let _levelExplicit = false;
 function applyClientLoggerConfig(options = {}) {
-	if (options.level) {
-		_level = options.level;
-		rootLogger.level = options.level;
-	}
+	if (options.explicit === false) _levelExplicit = false;
+	if (options.level !== void 0 && (options.explicit === true || !_levelExplicit)) rootLogger.level = options.level;
+	if (options.explicit === true) _levelExplicit = true;
 	if (options.format) _format = options.format;
+	if (options.destination) _destination = options.destination;
 }
-const outputStream = createLoggerOutputStream({ getFormat: () => _format });
+const outputStream = createLoggerOutputStream({
+	getFormat: () => _format,
+	getDestination: () => _destination
+});
 const rootLogger = (0, import_pino.default)({
-	level: _level,
-	timestamp: () => `,"time":"${formatLocalTime()}"`
+	level: initialPinoLevel,
+	timestamp: () => `,"time":"${formatLocalTime()}"`,
+	redact: {
+		paths: [...LOG_REDACT_PATHS],
+		censor: LOG_REDACT_CENSOR
+	}
 }, outputStream);
 if (initialLevel.fellBack) rootLogger.warn({ envValue: process.env.FIRST_TREE_HUB_LOG_LEVEL }, "invalid FIRST_TREE_HUB_LOG_LEVEL; falling back to info");
+function createLogger(module) {
+	return rootLogger.child({ module });
+}
+/**
+* Switch the client logger over to the background-service file sink.
+*
+* The launchd / systemd unit files already set `StandardOutPath` /
+* `StandardError` as a fallback for crash-time stderr; this routes normal
+* operational logs into a size-rotated NDJSON file at
+* `<logDir>/client.log` so it doesn't grow unbounded. Must be called once
+* at `client start` when running under `FIRST_TREE_HUB_SERVICE_MODE=1`.
+*/
+function configureClientLoggerForService(logDir) {
+	applyClientLoggerConfig({
+		format: "json",
+		destination: new RotatingFileStream({
+			path: join(logDir, "client.log"),
+			maxBytes: SERVICE_LOG_MAX_BYTES,
+			maxFiles: SERVICE_LOG_MAX_FILES
+		})
+	});
+}
 //#endregion
 //#region ../client/dist/index.mjs
 const adapterPlatformSchema = z.enum([
@@ -1148,6 +1287,8 @@ var ClientConnection = class extends EventEmitter {
 	registered = false;
 	/** Count of `server:welcome` frames received; drives `isReconnect` flag. */
 	welcomeFramesReceived = 0;
+	wsLogger;
+	authLogger;
 	boundAgents = /* @__PURE__ */ new Map();
 	/** Agents scheduled to rebind automatically on every reconnect. */
 	desiredBindings = /* @__PURE__ */ new Map();
@@ -1158,6 +1299,8 @@ var ClientConnection = class extends EventEmitter {
 		this.serverUrl = config.serverUrl.replace(/\/+$/, "");
 		this.sdkVersion = config.sdkVersion;
 		this.getAccessToken = config.getAccessToken;
+		this.wsLogger = createLogger("ws").child({ clientId: this.clientId });
+		this.authLogger = createLogger("auth").child({ clientId: this.clientId });
 		this.on("error", () => {});
 	}
 	get isConnected() {
@@ -1270,7 +1413,9 @@ var ClientConnection = class extends EventEmitter {
 	}
 	openWebSocket() {
 		return new Promise((resolve, reject) => {
-			const ws = new WebSocket(`${this.serverUrl.replace(/^http/, "ws")}/api/v1/agent/ws/client`);
+			const wsUrl = `${this.serverUrl.replace(/^http/, "ws")}/api/v1/agent/ws/client`;
+			this.wsLogger.info({ url: wsUrl }, "connecting");
+			const ws = new WebSocket(wsUrl);
 			let settled = false;
 			const settle = (fn, value) => {
 				if (settled) return;
@@ -1290,6 +1435,7 @@ var ClientConnection = class extends EventEmitter {
 			ws.on("open", async () => {
 				this.ws = ws;
 				this.reconnectAttempt = 0;
+				this.wsLogger.debug("socket opened, sending auth");
 				try {
 					const token = await this.getAccessToken();
 					ws.send(JSON.stringify({
@@ -1298,6 +1444,7 @@ var ClientConnection = class extends EventEmitter {
 					}));
 					this.scheduleProactiveAuthRefresh(token);
 				} catch (err) {
+					this.authLogger.error({ err }, "failed to obtain access token");
 					settle(reject, err instanceof Error ? err : new Error(String(err)));
 					ws.close();
 				}
@@ -1315,9 +1462,14 @@ var ClientConnection = class extends EventEmitter {
 				this.registered = false;
 				this.rejectAllPendingBinds("WebSocket closed");
 				if (!settled) {
+					this.wsLogger.warn({ code }, "closed before ready");
 					settle(reject, /* @__PURE__ */ new Error(`WebSocket closed before ready (code ${code})`));
 					return;
 				}
+				this.wsLogger.warn({
+					code,
+					wasRegistered
+				}, "disconnected");
 				if (!this.closing) {
 					this.emit("disconnected");
 					if (wasRegistered) this.scheduleReconnect();
@@ -1331,6 +1483,7 @@ var ClientConnection = class extends EventEmitter {
 	handleMessage(msg, connectResolve) {
 		const type = msg.type;
 		if (type === "auth:ok") {
+			this.authLogger.info("auth accepted, registering client");
 			this.ws?.send(JSON.stringify({
 				type: "client:register",
 				clientId: this.clientId,
@@ -1343,7 +1496,7 @@ var ClientConnection = class extends EventEmitter {
 		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`);
+				this.wsLogger.warn({ issues: parsed.error.issues.map((i) => i.message) }, "ignoring malformed server:welcome frame");
 				return;
 			}
 			const isReconnect = this.welcomeFramesReceived > 0;
@@ -1355,12 +1508,16 @@ var ClientConnection = class extends EventEmitter {
 			return;
 		}
 		if (type === "auth:rejected" || type === "auth:expired") {
-			if (type === "auth:expired") this.emit("auth:expired");
+			if (type === "auth:expired") {
+				this.authLogger.info("token expired, reconnecting with fresh token");
+				this.emit("auth:expired");
+			} else this.authLogger.warn("auth rejected by server");
 			this.ws?.close(4401, type);
 			return;
 		}
 		if (type === "client:register:rejected") {
 			const err = /* @__PURE__ */ new Error(`client:register rejected: ${msg.message ?? "unknown"}`);
+			this.wsLogger.error({ message: msg.message }, "client register rejected");
 			this.emit("error", err);
 			this.ws?.close(4403, "register rejected");
 			return;
@@ -1369,6 +1526,7 @@ var ClientConnection = class extends EventEmitter {
 			const isReconnect = this.boundAgents.size > 0 || this.desiredBindings.size > 0;
 			this.registered = true;
 			this.startHeartbeat();
+			this.wsLogger.info({ isReconnect }, "registered");
 			this.emit("connected");
 			connectResolve?.();
 			if (isReconnect) this.rebindAgents();
@@ -1476,6 +1634,10 @@ var ClientConnection = class extends EventEmitter {
 		this.reconnectAttempt++;
 		this.emit("reconnecting", this.reconnectAttempt);
 		const delay = Math.min(RECONNECT_BASE_MS * 2 ** (this.reconnectAttempt - 1), RECONNECT_MAX_MS);
+		this.wsLogger.debug({
+			attempt: this.reconnectAttempt,
+			delayMs: delay
+		}, "scheduling reconnect");
 		this.reconnectTimer = setTimeout(() => {
 			this.reconnectTimer = null;
 			if (!this.closing) this.openWebSocket().catch((err) => {
@@ -1531,9 +1693,11 @@ var ClientConnection = class extends EventEmitter {
 		if (!exp) return;
 		const delay = exp * 1e3 - Date.now() - AUTH_REFRESH_LEAD_MS;
 		if (delay <= 0) return;
+		this.authLogger.debug({ delayMs: delay }, "scheduled proactive auth refresh");
 		this.authRefreshTimer = setTimeout(() => {
 			this.authRefreshTimer = null;
 			if (this.closing) return;
+			this.authLogger.info("triggering proactive auth refresh");
 			this.ws?.close(1e3, "proactive auth refresh");
 		}, delay);
 	}
@@ -1890,7 +2054,7 @@ function looksLikeCommitSha(ref) {
 function createGitMirrorManager(opts) {
 	const mirrorsRoot = join(opts.dataDir, "git-mirrors");
 	const cloneTimeoutMs = opts.cloneTimeoutMs ?? Number(process.env.FIRST_TREE_HUB_GIT_CLONE_TIMEOUT_MS ?? DEFAULT_CLONE_TIMEOUT_MS);
-	const log = opts.log ?? (() => {});
+	const log = opts.log;
 	const urlLocks = /* @__PURE__ */ new Map();
 	function withUrlLock(url, op) {
 		const key = hashUrl(url);
@@ -2033,7 +2197,7 @@ function createGitMirrorManager(opts) {
 				"origin",
 				"--auto"
 			], mirrorPath, 3e4);
-			log("mirrorConfigMigrated", { gitUrl: url });
+			log?.info({ gitUrl: url }, "mirror config migrated");
 		}
 		return { migrated };
 	}
@@ -2137,22 +2301,22 @@ function createGitMirrorManager(opts) {
 				try {
 					await bootstrapMirror(path, url);
 					const elapsedMs = Date.now() - start;
-					log("ensureMirror", {
+					log?.debug({
 						gitUrl: url,
 						elapsedMs,
 						cloned: true
-					});
+					}, "mirror ensured");
 					return {
 						mirrorPath: path,
 						elapsedMs,
 						cloned: true
 					};
 				} catch (err) {
-					if (err instanceof GitMirrorTimeoutError) log("mirrorCloneTimeout", {
+					if (err instanceof GitMirrorTimeoutError) log?.warn({
 						gitUrl: url,
 						timeoutMs: cloneTimeoutMs,
 						elapsedMs: cloneTimeoutMs
-					});
+					}, "mirror clone timeout");
 					if (existsSync(path)) rmSync(path, {
 						recursive: true,
 						force: true
@@ -2173,11 +2337,11 @@ function createGitMirrorManager(opts) {
 					], path, cloneTimeoutMs);
 					return { elapsedMs };
 				} catch (err) {
-					log("mirrorFetchFailed", {
+					log?.warn({
 						gitUrl: url,
 						errorCode: err instanceof GitMirrorError ? "git-failed" : "unknown",
 						stderr: err instanceof Error ? err.message.slice(0, 1024) : String(err).slice(0, 1024)
-					});
+					}, "mirror fetch failed");
 					throw err;
 				}
 			});
@@ -2189,11 +2353,11 @@ function createGitMirrorManager(opts) {
 				const absTarget = resolve(targetPath);
 				const branchName = deriveSessionBranchName(sessionKey, url);
 				if (existsSync(absTarget) && !isHubManagedWorktree(absTarget)) {
-					log("worktreeCreateConflict", {
+					log?.warn({
 						gitUrl: url,
 						targetPath: absTarget,
 						occupantKind: classifyOccupant(absTarget)
-					});
+					}, "worktree create conflict");
 					throw new GitMirrorWorktreeConflictError(`Worktree target "${absTarget}" is already occupied by ${classifyOccupant(absTarget)} — aborting (D13)`);
 				}
 				const pathExists = existsSync(absTarget);
@@ -2409,6 +2573,17 @@ function cleanWorkspaces(workspaceRoot, activeChatIds, ttlMs = DEFAULT_WORKSPACE
 const MAX_RETRIES = 2;
 const TOOL_RESULT_PREVIEW_LIMIT = 400;
 const ASSISTANT_TEXT_EVENT_LIMIT = 8e3;
+const SUPPORTED_IMAGE_MIMES = new Set([
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+]);
+function isImageFileContent(content) {
+	if (!content || typeof content !== "object") return false;
+	const c = content;
+	return typeof c.data === "string" && typeof c.mimeType === "string" && typeof c.filename === "string" && SUPPORTED_IMAGE_MIMES.has(c.mimeType);
+}
 function extractContentBlocks(message) {
 	if (!message || typeof message !== "object") return [];
 	const inner = message.message;
@@ -2581,6 +2756,28 @@ const createClaudeCodeHandler = (config) => {
 	/** Worktrees materialised for this session — each entry removed on shutdown. */
 	const ownedWorktrees = [];
 	function toSDKUserMessage(message, sessionId) {
+		if (message.format === "file" && isImageFileContent(message.content)) {
+			const { data, mimeType, filename } = message.content;
+			return {
+				type: "user",
+				message: {
+					role: "user",
+					content: [{
+						type: "text",
+						text: `${message.senderId ? `[From: ${message.senderId}]\n\n` : ""}[Attached image: ${filename}]`
+					}, {
+						type: "image",
+						source: {
+							type: "base64",
+							media_type: mimeType,
+							data
+						}
+					}]
+				},
+				parent_tool_use_id: null,
+				session_id: sessionId
+			};
+		}
 		const rawContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
 		return {
 			type: "user",
@@ -2997,7 +3194,7 @@ function registerBuiltinHandlers() {
 }
 function createAgentConfigCache(opts) {
 	const { sdk } = opts;
-	const log = opts.log ?? (() => {});
+	const log = opts.log;
 	const entries = /* @__PURE__ */ new Map();
 	function urlsFromConfig(cfg) {
 		return new Set(cfg.payload.gitRepos.map((r) => r.url));
@@ -3042,7 +3239,10 @@ function createAgentConfigCache(opts) {
 			};
 			slot.inflight = doFetch(agentId).catch((err) => {
 				slot.inflight = null;
-				log(`[agent-config-cache] fetch failed for ${agentId}: ${err instanceof Error ? err.message : String(err)}`);
+				log?.warn({
+					agentId,
+					err
+				}, "agent config fetch failed");
 				throw err;
 			});
 			entries.set(agentId, slot);
@@ -3212,13 +3412,21 @@ var SessionManager = class {
 		const chatId = entry.chatId ?? entry.message.chatId;
 		const messageId = entry.message.id;
 		if (this.deduplicator.isDuplicate(messageId)) {
-			this.config.log(`Session ${chatId}: duplicate message ${messageId}, skipping`);
+			this.config.log.debug({
+				chatId,
+				messageId
+			}, "duplicate message, skipping");
 			return;
 		}
 		if (this.config.agentConfigCache) try {
 			await this.config.agentConfigCache.refreshIfNewer(this.config.agentIdentity.agentId, entry.message.configVersion);
 		} catch (err) {
-			this.config.log(`[configVersionMismatch] agentId=${this.config.agentIdentity.agentId} chatId=${chatId} incomingVersion=${entry.message.configVersion} action=skip — ${err instanceof Error ? err.message : String(err)}`);
+			this.config.log.warn({
+				chatId,
+				agentId: this.config.agentIdentity.agentId,
+				incomingVersion: entry.message.configVersion,
+				err
+			}, "config version mismatch — skipping refresh");
 		}
 		const message = this.extractMessage(entry);
 		await this.routeMessage(chatId, message, entry.id);
@@ -3228,7 +3436,7 @@ var SessionManager = class {
 		if (command === "session:suspend") {
 			const session = this.sessions.get(chatId);
 			if (session?.status === "active") {
-				this.config.log(`Session ${chatId}: suspend command received`);
+				this.config.log.info({ chatId }, "suspend command received");
 				this.suspendSession(session);
 			}
 			return;
@@ -3237,7 +3445,7 @@ var SessionManager = class {
 			const session = this.sessions.get(chatId);
 			const hadMapping = this.evictedMappings.has(chatId);
 			if (!session && !hadMapping) return;
-			this.config.log(`Session ${chatId}: terminate command received`);
+			this.config.log.info({ chatId }, "terminate command received");
 			if (session?.status === "active") {
 				this._activeCount--;
 				await session.handler.shutdown().catch(() => {});
@@ -3322,7 +3530,7 @@ var SessionManager = class {
 				await this.ackEntry(entryId, chatId);
 				existing.handler.inject(message);
 				existing.lastActivity = Date.now();
-				this.config.log(`Session ${chatId}: message injected`);
+				this.config.log.debug({ chatId }, "message injected");
 				return;
 			case "suspended":
 			case "evicted":
@@ -3357,16 +3565,26 @@ var SessionManager = class {
 			if (evicted) {
 				const sessionId = await handler.resume(message, evicted.claudeSessionId, ctx);
 				entry.claudeSessionId = sessionId;
-				this.config.log(`Session ${chatId}: resumed from eviction (${sessionId})`);
+				this.config.log.info({
+					chatId,
+					sessionId
+				}, "session resumed from eviction");
 			} else {
 				const sessionId = await handler.start(message, ctx);
 				entry.claudeSessionId = sessionId;
-				this.config.log(`Session ${chatId}: created (${sessionId})`);
+				this.config.log.info({
+					chatId,
+					sessionId
+				}, "session created");
 			}
 			this.persistRegistry();
 			this.notifySessionState(chatId, "active");
 		} catch (err) {
-			this.config.log(`Session ${chatId}: ${evicted ? "resume" : "start"} failed: ${err instanceof Error ? err.message : String(err)}`);
+			this.config.log.error({
+				chatId,
+				err,
+				phase: evicted ? "resume" : "start"
+			}, "session start/resume failed");
 			this.sessions.delete(chatId);
 			this.sessionRuntimeStates.delete(chatId);
 			this.recomputeRuntimeState();
@@ -3391,11 +3609,17 @@ var SessionManager = class {
 		entry.lastActivity = Date.now();
 		try {
 			await entry.handler.resume(message ?? void 0, entry.claudeSessionId, ctx);
-			this.config.log(`Session ${entry.chatId}: resumed (${entry.claudeSessionId})`);
+			this.config.log.info({
+				chatId: entry.chatId,
+				sessionId: entry.claudeSessionId
+			}, "session resumed");
 			this.persistRegistry();
 			this.notifySessionState(entry.chatId, "active");
 		} catch (err) {
-			this.config.log(`Session ${entry.chatId}: resume failed: ${err instanceof Error ? err.message : String(err)}`);
+			this.config.log.warn({
+				chatId: entry.chatId,
+				err
+			}, "resume failed");
 			entry.status = "suspended";
 			this._activeCount--;
 		}
@@ -3416,11 +3640,11 @@ var SessionManager = class {
 			if (!oldestActive || session.lastActivity < oldestActive.lastActivity) oldestActive = session;
 		}
 		if (oldestActive) {
-			this.config.log(`Session ${oldestActive.chatId}: preempted for concurrency`);
+			this.config.log.info({ chatId: oldestActive.chatId }, "session preempted for concurrency");
 			this.suspendSession(oldestActive);
 			return true;
 		}
-		this.config.log(`Session ${chatId}: concurrency limit reached, queuing`);
+		this.config.log.info({ chatId }, "concurrency limit reached, queuing");
 		this.pendingQueue.push({
 			message,
 			chatId,
@@ -3434,7 +3658,10 @@ var SessionManager = class {
 		this.sessionRuntimeStates.delete(entry.chatId);
 		this.recomputeRuntimeState();
 		entry.suspending = entry.handler.suspend().catch((err) => {
-			this.config.log(`Session ${entry.chatId}: suspend error: ${err instanceof Error ? err.message : String(err)}`);
+			this.config.log.warn({
+				chatId: entry.chatId,
+				err
+			}, "suspend error");
 		}).finally(() => {
 			entry.suspending = null;
 		});
@@ -3448,7 +3675,10 @@ var SessionManager = class {
 		const next = this.pendingQueue.shift();
 		if (!next) return;
 		this.routeMessage(next.chatId, next.message, next.entryId > 0 ? next.entryId : void 0).catch((err) => {
-			this.config.log(`Session ${next.chatId}: pending drain error: ${err instanceof Error ? err.message : String(err)}`);
+			this.config.log.warn({
+				chatId: next.chatId,
+				err
+			}, "pending drain error");
 		});
 	}
 	evictIfNeeded() {
@@ -3475,7 +3705,7 @@ var SessionManager = class {
 				claudeSessionId: candidate.session.claudeSessionId,
 				lastActivity: candidate.session.lastActivity
 			});
-			this.config.log(`Session ${candidate.key}: evicted (max_sessions reached)`);
+			this.config.log.info({ chatId: candidate.key }, "session evicted (max_sessions reached)");
 			if (candidate.session.status === "active") {
 				this._activeCount--;
 				candidate.session.handler.shutdown().catch(() => {});
@@ -3494,11 +3724,17 @@ var SessionManager = class {
 			if (session.status !== "active") continue;
 			const inactiveMs = now - session.lastActivity;
 			if (inactiveMs > timeoutMs) {
-				this.config.log(`Session ${session.chatId}: idle ${this.config.session.idle_timeout}s, suspending`);
+				this.config.log.info({
+					chatId: session.chatId,
+					idleTimeoutSec: this.config.session.idle_timeout
+				}, "session idle, suspending");
 				this.suspendSession(session);
 			} else if (inactiveMs > blockedThresholdMs) {
 				if (this.sessionRuntimeStates.get(session.chatId) === "working") {
-					this.config.log(`Session ${session.chatId}: working but no output for ${Math.round(inactiveMs / 1e3)}s, marking blocked`);
+					this.config.log.warn({
+						chatId: session.chatId,
+						inactiveSec: Math.round(inactiveMs / 1e3)
+					}, "session working but no output, marking blocked");
 					this.setSessionRuntimeState(session.chatId, "blocked");
 				}
 			}
@@ -3525,14 +3761,18 @@ var SessionManager = class {
 		try {
 			await this.config.sdk.ack(entryId);
 		} catch {
-			this.config.log(`Session ${chatId}: ACK failed for entry ${entryId}, continuing`);
+			this.config.log.warn({
+				chatId,
+				entryId
+			}, "ACK failed, continuing");
 		}
 	}
 	buildSessionContext(chatId) {
+		const sessionLog = this.config.log.child({ chatId });
 		return {
 			agent: this.config.agentIdentity,
 			sdk: this.config.sdk,
-			log: (msg) => this.config.log(`Session ${chatId}: ${msg}`),
+			log: (msg) => sessionLog.info(msg),
 			chatId,
 			touch: () => {
 				const entry = this.sessions.get(chatId);
@@ -3591,7 +3831,7 @@ var SessionManager = class {
 			claudeSessionId: data.claudeSessionId,
 			lastActivity: data.lastActivity
 		});
-		if (persisted.size > 0) this.config.log(`Loaded ${persisted.size} persisted session mapping(s)`);
+		if (persisted.size > 0) this.config.log.info({ count: persisted.size }, "loaded persisted session mappings");
 	}
 	persistRegistry() {
 		if (!this.registry) return;
@@ -3612,7 +3852,7 @@ var SessionManager = class {
 var AgentSlot = class {
 	sessionManager = null;
 	config;
-	logFn;
+	logger;
 	sdk = null;
 	agentConfigCache = null;
 	pollingTimer = null;
@@ -3620,9 +3860,10 @@ var AgentSlot = class {
 	listeners = [];
 	constructor(config) {
 		this.config = config;
-		this.logFn = (msg) => {
-			process.stderr.write(`[${config.name}] ${msg}\n`);
-		};
+		this.logger = createLogger("slot").child({
+			agentName: config.name,
+			agentId: config.agentId
+		});
 	}
 	get clientConnection() {
 		return this.config.clientConnection;
@@ -3642,21 +3883,21 @@ var AgentSlot = class {
 		const sdk = (await this.clientConnection.bindAgent(this.config.agentId, this.config.runtimeType ?? this.config.type, this.config.runtimeVersion)).sdk;
 		this.sdk = sdk;
 		const agent = await sdk.register();
-		this.logFn(`Bound as ${agent.displayName ?? agent.agentId} (${agent.agentId})`);
+		this.logger.info({ displayName: agent.displayName ?? agent.agentId }, "agent bound");
 		if (agent.type === "human") {
-			this.logFn("Server reports type=human — message processing disabled");
+			this.logger.info("server reports type=human — message processing disabled");
 			return agent;
 		}
 		this.agentConfigCache = createAgentConfigCache({
 			sdk,
-			log: this.logFn
+			log: this.logger
 		});
 		try {
 			const cfg = await this.agentConfigCache.refresh(agent.agentId);
-			this.logFn(`Loaded runtime config v${cfg.version}`);
+			this.logger.info({ version: cfg.version }, "runtime config loaded");
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			this.logFn(`Failed to fetch agent config — bind aborted: ${msg}`);
+			this.logger.error({ err }, "failed to fetch agent config — bind aborted");
 			throw new Error(`Hub unreachable while loading agent config: ${msg}`);
 		}
 		const onMessage = (agentId) => {
@@ -3687,7 +3928,10 @@ var AgentSlot = class {
 		const registryPath = join(DEFAULT_DATA_DIR, "sessions", `${this.config.name}.json`);
 		const gitMirrorManager = createGitMirrorManager({
 			dataDir: DEFAULT_DATA_DIR,
-			log: (event, fields) => this.logFn(`git[${event}] ${JSON.stringify(fields)}`)
+			log: createLogger("git-mirror").child({
+				agentName: this.config.name,
+				agentId: this.config.agentId
+			})
 		});
 		this.sessionManager = new SessionManager({
 			session: this.config.session,
@@ -3706,7 +3950,7 @@ var AgentSlot = class {
 				metadata: agent.metadata
 			},
 			sdk,
-			log: this.logFn,
+			log: this.logger,
 			registryPath,
 			agentConfigCache: this.agentConfigCache,
 			onStateChange: (chatId, state) => this.reportSessionState(chatId, state),
@@ -3716,7 +3960,11 @@ var AgentSlot = class {
 		});
 		const onCommand = (cmd) => {
 			if (cmd.agentId === this.config.agentId && this.sessionManager) this.sessionManager.handleCommand(cmd.chatId, cmd.type).catch((err) => {
-				this.logFn(`Session command error: ${err instanceof Error ? err.message : String(err)}`);
+				this.logger.error({
+					err,
+					chatId: cmd.chatId,
+					type: cmd.type
+				}, "session command error");
 			});
 		};
 		this.clientConnection.on("session:command", onCommand);
@@ -3744,7 +3992,7 @@ var AgentSlot = class {
 		this.listeners = [];
 		await this.clientConnection.unbindAgent(this.config.agentId);
 		await this.sessionManager?.shutdown();
-		this.logFn("Stopped");
+		this.logger.info("stopped");
 	}
 	reportSessionState(chatId, state) {
 		this.clientConnection.reportSessionState(this.config.agentId, chatId, state);
@@ -3786,7 +4034,7 @@ var AgentSlot = class {
 			const { entries } = await this.sdk.pull(10);
 			for (const entry of entries) await this.sessionManager.dispatch(entry);
 		} catch (err) {
-			this.logFn(`Poll error: ${err instanceof Error ? err.message : String(err)}`);
+			this.logger.warn({ err }, "poll error");
 		}
 	}
 };
@@ -3963,6 +4211,71 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
+//#region src/core/output.ts
+/**
+* Print layer — the only place CLI code should write to stdout/stderr.
+*
+* Contract:
+* - `print.result(data)` / `print.fail(...)` emit machine-readable JSON on
+*   stdout / stderr respectively. Scripts pipe into `jq` and expect a clean
+*   envelope, so nothing else may touch stdout.
+* - `print.status` / `print.check` / `print.blank` / `print.line` are
+*   human-friendly and go to stderr so they never pollute a redirected stdout.
+*   In `--json` mode they are silenced — scripted consumers only care about
+*   the envelope.
+*/
+let jsonMode = false;
+function setJsonMode(enabled) {
+	jsonMode = enabled;
+}
+function result(data) {
+	process.stdout.write(`${JSON.stringify({
+		ok: true,
+		data
+	})}\n`);
+}
+function fail(code, message, exitCode = 1) {
+	process.stderr.write(`${JSON.stringify({
+		ok: false,
+		error: {
+			code,
+			message
+		}
+	})}\n`);
+	process.exit(exitCode);
+}
+function status(label, message) {
+	if (jsonMode) return;
+	process.stderr.write(`  ${label.padEnd(20)} ${message}\n`);
+}
+function check(pass, label, detail = "") {
+	if (jsonMode) return;
+	const icon = pass ? "✓" : "✗";
+	const tail = detail ? ` ${detail}` : "";
+	process.stderr.write(`  ${icon} ${label.padEnd(22)}${tail}\n`);
+}
+function blank() {
+	if (jsonMode) return;
+	process.stderr.write("\n");
+}
+/**
+* Generic stderr writer for pre-formatted human text (multi-line tables,
+* interactive prompts). Prefer `status` / `check` when the text fits; this
+* exists so the `--json` mode gate can silence arbitrary human chatter.
+*/
+function line(text) {
+	if (jsonMode) return;
+	process.stderr.write(text);
+}
+const print = {
+	result,
+	fail,
+	status,
+	check,
+	blank,
+	line
+};
+//#endregion
 //#region src/core/admin.ts
 /**
 * Check if any user exists.
@@ -4083,10 +4396,10 @@ var ClientRuntime = class {
 		});
 		registerBuiltinHandlers();
 		this.connection.on("auth:expired", () => {
-			process.stderr.write("  ⚠️  Access token expired — reconnecting after refresh...\n");
+			print.status("⚠️", "access token expired — reconnecting after refresh...");
 		});
 		this.connection.on("error", (err) => {
-			process.stderr.write(`  \u26A0\uFE0F  Client connection error: ${err.message}\n`);
+			print.status("⚠️", `client connection error: ${err.message}`);
 		});
 		this.connection.on("agent:pinned", (message) => {
 			this.handleAgentPinned(message);
@@ -4121,27 +4434,30 @@ var ClientRuntime = class {
 			currentVersion: this.options.currentVersion,
 			...this.options.update,
 			isTTY: Boolean(process.stdout.isTTY),
-			log: (level, msg) => process.stderr.write(`  [update/${level}] ${msg}\n`),
+			log: (level, msg) => print.status(`[update/${level}]`, msg),
 			getQuietGateSnapshot: () => this.aggregateQuietGate()
 		});
 		await this.connection.connect();
-		process.stderr.write(`  \u2713 Client registered: ${this.connection.clientId}\n`);
+		print.check(true, "client registered", this.connection.clientId);
 		if (this.agents.length === 0) {
-			process.stderr.write("\n  No agents configured yet.\n");
-			process.stderr.write("  Add one with: first-tree-hub agent create <name> --type claude-code --client-id <id>\n\n");
+			print.blank();
+			print.status("", "no agents configured yet.");
+			print.status("", "add one with: first-tree-hub agent create <name> --type claude-code --client-id <id>");
+			print.blank();
 			return;
 		}
 		await Promise.allSettled(this.agents.map(async (agent) => {
 			try {
 				const identity = await agent.slot.start();
-				process.stderr.write(`  \u2713 ${agent.name}: connected (agent: ${identity.displayName ?? identity.agentId})\n`);
+				print.check(true, `${agent.name}: connected`, `agent: ${identity.displayName ?? identity.agentId}`);
 			} catch (error) {
 				const msg = error instanceof Error ? error.message : String(error);
-				process.stderr.write(`  \u2717 ${agent.name}: connection failed \u2014 ${msg}\n`);
+				print.check(false, `${agent.name}: connection failed`, msg);
 			}
 		}));
 		const connected = this.agents.length;
-		process.stderr.write(`\n  ${connected} agent(s) running. Press Ctrl+C to stop.\n`);
+		print.blank();
+		print.status("", `${connected} agent(s) running. Press Ctrl+C to stop.`);
 	}
 	watchAgentsDir(agentsDir) {
 		this.agentsDir = agentsDir;
@@ -4194,7 +4510,8 @@ var ClientRuntime = class {
 			for (const [name, config] of all) {
 				if (this.agentNames.has(name)) continue;
 				if (this.agentIds.has(config.agentId)) continue;
-				process.stderr.write(`\n  New agent detected: ${name}\n`);
+				print.blank();
+				print.status("", `new agent detected: ${name}`);
 				this.addAgent(name, config);
 				this.startAgent(name);
 			}
@@ -4209,7 +4526,7 @@ var ClientRuntime = class {
 	handleAgentPinned(message) {
 		if (this.agentIds.has(message.agentId)) return;
 		if (!this.agentsDir) {
-			process.stderr.write(`  \u26A0\uFE0F  Agent pinned (${message.agentId}) but no agents dir set — cannot auto-register.\n`);
+			print.status("⚠️", `agent pinned (${message.agentId}) but no agents dir set — cannot auto-register.`);
 			return;
 		}
 		const localName = this.pickLocalName(message);
@@ -4224,10 +4541,10 @@ var ClientRuntime = class {
 				runtime: "claude-code"
 			});
 			writeFileSync(join(agentDir, "agent.yaml"), yaml, { mode: 384 });
-			process.stderr.write(`  \u2713 Auto-added agent "${localName}" (${message.agentId}) from server push.\n`);
+			print.check(true, `auto-added agent "${localName}"`, `${message.agentId} (from server push)`);
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			process.stderr.write(`  \u2717 Failed to auto-add agent "${localName}": ${msg}\n`);
+			print.check(false, `failed to auto-add agent "${localName}"`, msg);
 			return;
 		}
 		this.scanForNewAgents(this.agentsDir);
@@ -4259,10 +4576,10 @@ var ClientRuntime = class {
 		const entry = this.agents.find((a) => a.name === name);
 		if (!entry) return;
 		entry.slot.start().then((identity) => {
-			process.stderr.write(`  \u2713 ${name}: connected (agent: ${identity.displayName ?? identity.agentId})\n`);
+			print.check(true, `${name}: connected`, `agent: ${identity.displayName ?? identity.agentId}`);
 		}).catch((err) => {
 			const msg = err instanceof Error ? err.message : String(err);
-			process.stderr.write(`  \u2717 ${name}: connection failed \u2014 ${msg}\n`);
+			print.check(false, `${name}: connection failed`, msg);
 		});
 	}
 };
@@ -4441,16 +4758,6 @@ function getContainerPassword() {
 	throw new Error("Cannot determine PostgreSQL password from container");
 }
 //#endregion
-//#region src/core/output.ts
-/** Print a styled status line to stderr (human-friendly output). */
-function status(label, message) {
-	process.stderr.write(`  ${label.padEnd(20)} ${message}\n`);
-}
-/** Print a blank line to stderr. */
-function blank() {
-	process.stderr.write("\n");
-}
-//#endregion
 //#region src/core/doctor.ts
 function getServerConfig() {
 	return resolveConfigReadonly({
@@ -4691,12 +4998,12 @@ async function checkWebSocket() {
 function printResults(results) {
 	for (const r of results) {
 		const icon = r.ok ? "✓" : "✗";
-		process.stderr.write(`  ${icon} ${r.label.padEnd(22)} ${r.detail}\n`);
+		print.line(`  ${icon} ${r.label.padEnd(22)} ${r.detail}\n`);
 	}
 	blank();
 	const failures = results.filter((r) => !r.ok);
-	if (failures.length === 0) process.stderr.write("  All checks passed.\n");
-	else process.stderr.write(`  ${failures.length} issue(s) found.\n`);
+	if (failures.length === 0) print.line("  All checks passed.\n");
+	else print.line(`  ${failures.length} issue(s) found.\n`);
 	blank();
 }
 //#endregion
@@ -4782,7 +5089,7 @@ function sleepSync(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");
+const LOG_DIR$1 = join(DEFAULT_HOME_DIR$1, "logs");
 function whichBin(name) {
 	try {
 		return execFileSync(process.platform === "win32" ? "where" : "which", [name], {
@@ -4824,7 +5131,7 @@ function resolveCliInvocation() {
 	};
 }
 function ensureLogDir() {
-	mkdirSync(LOG_DIR, {
+	mkdirSync(LOG_DIR$1, {
 		recursive: true,
 		mode: 448
 	});
@@ -4845,8 +5152,8 @@ function renderPlist(invocation) {
 		"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");
+	const stdoutFallback = join(LOG_DIR$1, "client.stdout.log");
+	const stderrFallback = join(LOG_DIR$1, "client.stderr.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">
@@ -4861,6 +5168,8 @@ ${argsXml}
   <dict>
     <key>PATH</key>
     <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+    <key>FIRST_TREE_HUB_SERVICE_MODE</key>
+    <string>1</string>
   </dict>
   <key>RunAtLoad</key>
   <true/>
@@ -4872,9 +5181,9 @@ ${argsXml}
   <key>ThrottleInterval</key>
   <integer>10</integer>
   <key>StandardOutPath</key>
-  <string>${escapeXml(outLog)}</string>
+  <string>${escapeXml(stdoutFallback)}</string>
   <key>StandardErrorPath</key>
-  <string>${escapeXml(errLog)}</string>
+  <string>${escapeXml(stderrFallback)}</string>
 </dict>
 </plist>
 `;
@@ -4947,7 +5256,7 @@ function installLaunchd() {
 	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`);
+		if (!/not find|no such|not loaded/i.test(bootoutRes.stderr)) print.line(`    warning: launchctl bootout: ${bootoutRes.stderr || `exit ${bootoutRes.code ?? "unknown"}`}\n`);
 	}
 	waitForLabelEvicted(target, LAUNCHD_LABEL, 1e4);
 	let lastBootstrapErr = null;
@@ -4966,13 +5275,13 @@ function installLaunchd() {
 	}
 	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`);
+	if (!enableRes.ok) print.line(`    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,
+		logDir: LOG_DIR$1,
 		state,
 		detail
 	};
@@ -4980,13 +5289,13 @@ function installLaunchd() {
 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 (!res.ok && !/not find|no such|not loaded/i.test(res.stderr)) print.line(`    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,
+		logDir: LOG_DIR$1,
 		state: "not-installed"
 	};
 }
@@ -5004,9 +5313,10 @@ 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")}
+StandardOutput=append:${join(LOG_DIR$1, "client.stdout.log")}
+StandardError=append:${join(LOG_DIR$1, "client.stderr.log")}
 Environment=PATH=/usr/local/bin:/usr/bin:/bin
+Environment=FIRST_TREE_HUB_SERVICE_MODE=1
 
 [Install]
 WantedBy=default.target
@@ -5061,7 +5371,7 @@ function installSystemd() {
 		platform: "systemd",
 		label: SYSTEMD_UNIT,
 		unitPath,
-		logDir: LOG_DIR,
+		logDir: LOG_DIR$1,
 		state,
 		detail
 	};
@@ -5074,15 +5384,15 @@ function uninstallSystemd() {
 		"--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 (!disableRes.ok && !/not found|no such|not loaded/i.test(disableRes.stderr)) print.line(`    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`);
+	if (!reloadRes.ok) print.line(`    warning: systemctl daemon-reload during uninstall: ${reloadRes.stderr || `exit ${reloadRes.code ?? "unknown"}`}\n`);
 	return {
 		platform: "systemd",
 		label: SYSTEMD_UNIT,
 		unitPath,
-		logDir: LOG_DIR,
+		logDir: LOG_DIR$1,
 		state: "not-installed"
 	};
 }
@@ -5108,7 +5418,7 @@ function getClientServiceStatus() {
 			platform: "launchd",
 			label: LAUNCHD_LABEL,
 			unitPath: launchdPlistPath(),
-			logDir: LOG_DIR,
+			logDir: LOG_DIR$1,
 			state,
 			detail
 		};
@@ -5119,7 +5429,7 @@ function getClientServiceStatus() {
 			platform: "systemd",
 			label: SYSTEMD_UNIT,
 			unitPath: systemdUnitPath(),
-			logDir: LOG_DIR,
+			logDir: LOG_DIR$1,
 			state,
 			detail
 		};
@@ -5128,7 +5438,7 @@ function getClientServiceStatus() {
 		platform: "unsupported",
 		label: "",
 		unitPath: "",
-		logDir: LOG_DIR,
+		logDir: LOG_DIR$1,
 		state: "not-installed",
 		detail: `platform ${process.platform} not supported`
 	};
@@ -5168,22 +5478,22 @@ function runHomeMigration() {
 		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`);
+		if (result.reason === "failed") print.line(`[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`);
+	print.line(`[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");
+		print.line("[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`);
+		print.line(`[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`);
+		print.line(`[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
@@ -5319,7 +5629,7 @@ async function onboardCreate(args) {
 	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`);
+	print.line(`Creating agent "${args.id}"...\n`);
 	const primary = await createAgentViaAdmin(serverUrl, accessToken, {
 		name: args.id,
 		type: args.type,
@@ -5328,11 +5638,11 @@ 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`);
+	print.line(`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`);
+		print.line(`Creating assistant "${args.assistant}"...\n`);
 		try {
 			const assistant = await createAgentViaAdmin(serverUrl, accessToken, {
 				name: args.assistant,
@@ -5346,21 +5656,21 @@ async function onboardCreate(args) {
 			});
 			assistantUuid = assistant.uuid;
 			saveAgentConfig(args.assistant, assistant.uuid, "claude-code");
-			process.stderr.write(`Assistant "${args.assistant}" ready.\n`);
+			print.line(`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`);
+			print.line(`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`);
+		if (!targetAgentUuid) print.line(`Warning: Cannot bind Feishu bot — no runtime agent available for "${args.id}".\n`);
 		else {
-			process.stderr.write("Binding Feishu bot...\n");
+			print.line("Binding Feishu bot...\n");
 			await bindFeishuBot(serverUrl, accessToken, targetAgentUuid, args.feishuBotAppId, args.feishuBotAppSecret);
-			process.stderr.write("Feishu bot bound.\n");
+			print.line("Feishu bot bound.\n");
 		}
 	}
 	setConfigValue(join(DEFAULT_CONFIG_DIR, "client.yaml"), "server.url", serverUrl);
@@ -5369,21 +5679,21 @@ async function onboardCreate(args) {
 		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`);
+	print.line("\n✅ Onboard complete!\n\n");
+	print.line(`  ${typeLabel}:${" ".repeat(Math.max(1, 10 - typeLabel.length))}${args.id}\n`);
+	if (args.assistant) print.line(`  Assistant: ${args.assistant}\n`);
+	if (runtimeAgent) print.line(`  Config:    ${DEFAULT_HOME_DIR$1}/config/agents/${runtimeAgent}/agent.yaml\n`);
+	if (args.feishuBotAppId) print.line(`  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");
+		print.line("\n  Next step — bind your Feishu account:\n");
+		print.line(`    Send this message to the bot in Feishu:  /bind ${args.id}\n`);
+		if (!args.feishuBotAppId) print.line("    (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");
+		print.line("\n  Start the agent:\n");
+		print.line("    first-tree-hub client start\n");
 	}
-	process.stderr.write("\n");
+	print.line("\n");
 }
 //#endregion
 //#region src/core/prompt.ts
@@ -5495,2713 +5805,7 @@ function setNestedByDot(obj, dotPath, value) {
 	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 {
-			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();
-			});
-			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;
-	}
-	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
-		});
-	}
-	/**
-	* @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;
-	}
-	/**
-	* @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;
-		}
-	}
-	/**
-	* @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;
-		}
-	}
-	module.exports = parse;
-	module.exports.default = parse;
-	module.exports.parse = parse;
-	module.exports.safeParse = safeParse;
-	module.exports.scan = filter;
-}));
-//#endregion
-//#region ../server/dist/app-BcKNAbK-.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;
-		}
-	}
-	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();
-		});
-		const defaultThrowFileSizeLimit = typeof options.throwFileSizeLimit === "boolean" ? options.throwFileSizeLimit : true;
-		fastify.decorate("multipartErrors", {
-			PartsLimitError,
-			FilesLimitError,
-			FieldsLimitError,
-			PrototypeViolationError,
-			InvalidMultipartContentTypeError,
-			RequestFileTooLargeError,
-			FileBufferNotFoundError
-		});
-		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();
-	}
-	/**
-	* 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" }
-		});
-	}
-	/**
-	* 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);
+//#region ../server/dist/app-Frne_Mbn.mjs
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -8996,7 +6600,7 @@ async function deleteAdapterConfig(db, id) {
 	const [row] = await db.delete(adapterConfigs).where(eq(adapterConfigs.id, id)).returning();
 	if (!row) throw new NotFoundError(`Adapter config "${id}" not found`);
 }
-const log$4 = createLogger("AdminAdapters");
+const log$4 = createLogger$1("AdminAdapters");
 function parseId(raw) {
 	const id = Number(raw);
 	if (!Number.isInteger(id) || id <= 0) throw new BadRequestError(`Invalid adapter ID: "${raw}"`);
@@ -9101,8 +6705,7 @@ async function adminAgentClientStatusRoutes(app) {
 }
 async function adminAgentConfigRoutes(app) {
 	app.get("/:uuid/config", async (request) => {
-		const scope = memberScope(request);
-		await assertAgentVisible(app.db, scope, request.params.uuid);
+		await assertCanManage(app.db, memberScope(request), request.params.uuid);
 		return await app.configService.get(request.params.uuid);
 	});
 	app.patch("/:uuid/config", async (request) => {
@@ -12313,99 +9916,6 @@ 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));
@@ -12574,7 +10084,7 @@ async function agentConfigRoutes(app) {
 		return await app.configService.getDecrypted(identity.uuid);
 	});
 }
-const log$3 = createLogger("AgentFeishuBot");
+const log$3 = createLogger$1("AgentFeishuBot");
 async function agentFeishuBotRoutes(app) {
 	/**
 	* PUT /agent/me/feishu-bot
@@ -12839,7 +10349,7 @@ async function agentMeRoutes(app) {
 		};
 	});
 }
-const log$2 = createLogger("AgentMessages");
+const log$2 = createLogger$1("AgentMessages");
 const editMessageSchema = z.object({
 	format: z.string().optional(),
 	content: z.unknown()
@@ -13819,7 +11329,7 @@ async function memberRoutes(app) {
 		return reply.status(204).send();
 	});
 }
-const log$1 = createLogger("GithubWebhook");
+const log$1 = createLogger$1("GithubWebhook");
 const GITHUB_ADAPTER_ID = "github-adapter";
 function verifySignature(secret, rawBody, signatureHeader) {
 	const expected = `sha256=${createHmac("sha256", secret).update(rawBody).digest("hex")}`;
@@ -14886,7 +12396,7 @@ function formatForFeishu(format, content) {
 		content: JSON.stringify({ text })
 	};
 }
-const log = createLogger("BackgroundTasks");
+const log = createLogger$1("BackgroundTasks");
 function createBackgroundTasks(app, instanceId, adapterManager, kaelRuntime) {
 	let inboxTimer = null;
 	let heartbeatTimer = null;
@@ -15529,7 +13039,6 @@ async function buildApp(config) {
 	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, {
@@ -15568,14 +13077,12 @@ 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);
 		}, { prefix: "/admin/agents" });
 		await api.register(async (adminApp) => {
 			adminApp.addHook("onRequest", memberAuth);
-			adminApp.addHook("onRequest", adminOnly);
 			await adminApp.register(adminAgentConfigRoutes);
 		}, { prefix: "/admin/agents" });
 		await api.register(async (adminApp) => {
@@ -15615,10 +13122,6 @@ 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);
@@ -15695,7 +13198,7 @@ async function buildApp(config) {
 		notifier,
 		broadcast: broadcastToAdmins
 	});
-	const hotReloadLog = createLogger("HotReload");
+	const hotReloadLog = createLogger$1("HotReload");
 	notifier.onConfigChange((configType) => {
 		if (configType === "adapter_configs") {
 			adapterManager.reload().catch((err) => hotReloadLog.error({ err }, "adapter hot-reload failed (PG NOTIFY)"));
@@ -15763,7 +13266,7 @@ function resolveCommandVersion(moduleUrl = import.meta.url) {
 			const code = err.code;
 			if (code !== "ENOENT" && code !== "ENOTDIR") {
 				const message = err instanceof Error ? err.message : String(err);
-				process.stderr.write(`[first-tree-hub] warning: could not read ${dir}/package.json: ${message}\n`);
+				print.line(`[first-tree-hub] warning: could not read ${dir}/package.json: ${message}\n`);
 			}
 		}
 		const parent = dirname(dir);
@@ -15786,7 +13289,7 @@ const COMMAND_VERSION = resolveCommandVersion();
 * 7. Start Fastify server
 */
 async function startServer(options) {
-	process.stderr.write(`\n  First Tree Hub v${COMMAND_VERSION}\n\n`);
+	print.line(`\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 = {
@@ -15828,11 +13331,11 @@ async function startServer(options) {
 		instanceId: `srv_${randomUUID().slice(0, 8)}`,
 		commandVersion: COMMAND_VERSION
 	};
-	const { initTelemetry, shutdownTelemetry } = await import("./observability-Xi-sEZI7.mjs");
+	const { initTelemetry, shutdownTelemetry } = await import("./observability-hDEdrmMS.mjs");
 	await initTelemetry(serverConfig.observability.tracing, config.instanceId);
 	const app = await buildApp(config);
 	const shutdown = async () => {
-		process.stderr.write("\n  Shutting down...\n");
+		print.line("\n  Shutting down...\n");
 		try {
 			await app.close();
 		} finally {
@@ -15849,8 +13352,8 @@ async function startServer(options) {
 	blank();
 	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");
+	print.line("  Open the URL above in your browser to get started.\n");
+	print.line("  Press Ctrl+C to stop.\n\n");
 }
 /**
 * Resolve web dist path.
@@ -15878,6 +13381,175 @@ function resolveWebDist() {
 	} catch {}
 }
 //#endregion
+//#region src/core/service-logs.ts
+const LOG_DIR = join(DEFAULT_HOME_DIR$1, "logs");
+const PRIMARY_LOG = join(LOG_DIR, "client.log");
+const FALLBACK_STDOUT = join(LOG_DIR, "client.stdout.log");
+const FALLBACK_STDERR = join(LOG_DIR, "client.stderr.log");
+/**
+* Duration string → milliseconds. Accepts `10s`, `5m`, `2h`, `1d`; rejects
+* everything else. Keeps the parser tiny rather than pulling in a library —
+* the `--since` flag is the only consumer.
+*/
+function parseDuration(input) {
+	const match = /^(\d+)\s*(s|m|h|d)$/.exec(input.trim());
+	if (!match) throw new Error(`invalid duration "${input}" (expected e.g. 30s, 5m, 2h, 1d)`);
+	return Number(match[1]) * ({
+		s: 1e3,
+		m: 6e4,
+		h: 36e5,
+		d: 864e5
+	}[match[2]] ?? 0);
+}
+const LEVEL_RANK = {
+	trace: 10,
+	debug: 20,
+	info: 30,
+	warn: 40,
+	error: 50,
+	fatal: 60
+};
+/** Rotated log files, newest-first. Missing files are silently skipped. */
+function listLogFilesNewestFirst() {
+	const files = [];
+	if (existsSync(PRIMARY_LOG)) files.push(PRIMARY_LOG);
+	for (let i = 1;; i++) {
+		const p = `${PRIMARY_LOG}.${i}`;
+		if (!existsSync(p)) break;
+		files.push(p);
+	}
+	return files;
+}
+/** Supervisor fallback files (raw stdout/stderr, not NDJSON). Missing files skipped. */
+function listFallbackFiles() {
+	const files = [];
+	if (existsSync(FALLBACK_STDERR)) files.push(FALLBACK_STDERR);
+	if (existsSync(FALLBACK_STDOUT)) files.push(FALLBACK_STDOUT);
+	return files;
+}
+function matchesFilters(obj, minLevel, cutoffMs) {
+	if (minLevel !== void 0) {
+		const lvl = typeof obj.level === "number" ? obj.level : NaN;
+		if (!Number.isFinite(lvl) || lvl < minLevel) return false;
+	}
+	if (cutoffMs !== void 0) {
+		const t = parseLogTime(obj.time);
+		if (t === null || t < cutoffMs) return false;
+	}
+	return true;
+}
+/** Logger writes `time` as a local-ish string (`YYYY-MM-DD HH:mm:ss`). */
+function parseLogTime(value) {
+	if (typeof value === "number") return value;
+	if (typeof value !== "string") return null;
+	const iso = value.replace(" ", "T");
+	const ms = Date.parse(iso);
+	return Number.isFinite(ms) ? ms : null;
+}
+function renderLine(line, json) {
+	if (!line.trim()) return null;
+	if (json) return `${line}\n`;
+	try {
+		return formatPrettyEntry$1(line);
+	} catch {
+		return `${line}\n`;
+	}
+}
+function processLogLine(line, minLevel, cutoffMs, json) {
+	let obj;
+	try {
+		obj = JSON.parse(line);
+	} catch {
+		return json ? null : `${line}\n`;
+	}
+	if (!matchesFilters(obj, minLevel, cutoffMs)) return null;
+	return renderLine(line, json);
+}
+async function readFileLines(path, minLevel, cutoffMs, json) {
+	const rl = createInterface({ input: createReadStream(path, { encoding: "utf8" }) });
+	for await (const line of rl) {
+		const rendered = processLogLine(line, minLevel, cutoffMs, json);
+		if (rendered) process.stdout.write(rendered);
+	}
+}
+/**
+* Read a supervisor fallback file (launchd / systemd stdout/stderr capture).
+* These are plain text, not NDJSON: level and time filters don't apply, so we
+* honour `--since` by dropping the whole file when its mtime predates the
+* cutoff and otherwise pass every line through. In pretty mode each line is
+* tagged with the source so operators can tell it apart from pino output; in
+* `--json` mode we emit a synthetic record so NDJSON consumers keep one
+* object per line.
+*/
+async function readFallbackFile(path, cutoffMs, json) {
+	try {
+		const mtime = statSync(path).mtimeMs;
+		if (cutoffMs !== void 0 && mtime < cutoffMs) return;
+	} catch {
+		return;
+	}
+	const source = path.endsWith(".stderr.log") ? "supervisor:stderr" : "supervisor:stdout";
+	const rl = createInterface({ input: createReadStream(path, { encoding: "utf8" }) });
+	for await (const line of rl) {
+		if (!line.trim()) continue;
+		if (json) process.stdout.write(`${JSON.stringify({
+			source,
+			line
+		})}\n`);
+		else process.stdout.write(`[${source}] ${line}\n`);
+	}
+}
+/**
+* Print existing log history, applying filters. `--tail` then switches to
+* follow mode and keeps printing new lines as the active file grows; rotation
+* is not handled during the tail (a follow-up rotation will simply stop
+* emitting new lines — operator can re-run the command).
+*/
+async function showServiceLogs(options) {
+	if (!existsSync(LOG_DIR)) {
+		print.status("logs", `directory not found: ${LOG_DIR}`);
+		return;
+	}
+	const minLevel = options.level ? LEVEL_RANK[options.level] : void 0;
+	const cutoffMs = options.sinceMs !== void 0 ? Date.now() - options.sinceMs : void 0;
+	for (const f of listFallbackFiles()) await readFallbackFile(f, cutoffMs, options.json);
+	const files = listLogFilesNewestFirst().reverse();
+	for (const f of files) await readFileLines(f, minLevel, cutoffMs, options.json);
+	if (!options.tail) return;
+	if (!existsSync(PRIMARY_LOG)) print.status("tail", "waiting for client.log to appear...");
+	await new Promise((resolve) => {
+		let position = existsSync(PRIMARY_LOG) ? statSync(PRIMARY_LOG).size : 0;
+		const onChange = () => {
+			if (!existsSync(PRIMARY_LOG)) return;
+			const current = statSync(PRIMARY_LOG).size;
+			if (current < position) position = 0;
+			if (current <= position) return;
+			const stream = createReadStream(PRIMARY_LOG, {
+				start: position,
+				end: current - 1,
+				encoding: "utf8"
+			});
+			position = current;
+			createInterface({ input: stream }).on("line", (line) => {
+				const rendered = processLogLine(line, minLevel, cutoffMs, options.json);
+				if (rendered) process.stdout.write(rendered);
+			});
+		};
+		watchFile(PRIMARY_LOG, { interval: 500 }, onChange);
+		process.once("SIGINT", () => {
+			unwatchFile(PRIMARY_LOG, onChange);
+			resolve();
+		});
+	});
+}
+/** Validated flag parsers the CLI layer can reuse without re-doing the work. */
+function validateLevel(value) {
+	if (value === void 0) return void 0;
+	const parsed = parseLogLevel$1(value);
+	if (parsed.fellBack) throw new Error(`invalid --level "${value}" (expected one of ${LOG_LEVELS$1.join(", ")})`);
+	return parsed.level;
+}
+//#endregion
 //#region src/core/update.ts
 const PACKAGE_NAME = "@agent-team-foundation/first-tree-hub";
 /**
@@ -15947,7 +13619,7 @@ async function installGlobalLatest() {
 		child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
 		child.stderr.on("data", (chunk) => {
 			stderrChunks.push(chunk);
-			process.stderr.write(chunk);
+			print.line(chunk.toString("utf8"));
 		});
 		child.on("error", (err) => {
 			resolvePromise({
@@ -16031,27 +13703,27 @@ 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");
+			print.line("  [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");
+			print.line("  [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");
+		print.line("  [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`);
+			print.line(`  [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`);
+			print.line(`  [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`);
+		print.line(`  [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 };
 	};
 }
 //#endregion
-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 };
+export { checkServerHealth as A, blank as B, runMigrations as C, checkDocker as D, checkDatabase as E, isDockerAvailable as F, SdkError as G, setJsonMode as H, stopPostgres as I, applyClientLoggerConfig as J, SessionRegistry as K, ClientRuntime as L, checkWebSocket as M, printResults as N, checkNodeVersion as O, ensurePostgres as P, createOwner as R, uninstallClientService as S, checkClientConfig as T, status as U, print as V, FirstTreeHubSDK as W, configureClientLoggerForService as Y, runHomeMigration as _, showServiceLogs as a, isServiceSupported as b, COMMAND_VERSION as c, promptMissingFields as d, formatCheckReport as f, saveOnboardState as g, onboardCreate as h, parseDuration as i, checkServerReachable as j, checkServerConfig as k, isInteractive as l, onboardCheck as m, declineUpdate as n, validateLevel as o, loadOnboardState as p, cleanWorkspaces as q, promptUpdate as r, startServer as s, createExecuteUpdate as t, promptAddAgent as u, getClientServiceStatus as v, checkAgentConfigs as w, resolveCliInvocation as x, installClientService as y, hasUser as z };