orionfold-relay 0.15.4 → 0.16.0

package/dist/cli.js

@@ -27,11 +27,11 @@ var __copyProps = (to, from, except, desc16) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/utils/app-root.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join2, dirname as dirname2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
 function getAppRoot(metaDirname, depth) {
   if (metaDirname) {
-    const candidate = join2(metaDirname, ...Array(depth).fill(".."));
+    const candidate = join3(metaDirname, ...Array(depth).fill(".."));
     if (isPackageRoot(candidate)) return candidate;
     let dir = metaDirname;
     while (true) {
@@ -44,10 +44,10 @@ function getAppRoot(metaDirname, depth) {
   return process.cwd();
 }
 function isPackageRoot(dir) {
-  const pkgPath = join2(dir, "package.json");
-  if (!existsSync2(pkgPath)) return false;
+  const pkgPath = join3(dir, "package.json");
+  if (!existsSync3(pkgPath)) return false;
   try {
-    const pkg2 = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkg2 = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     return pkg2.name === PKG_NAME;
   } catch {
     return false;
@@ -63,17 +63,17 @@ var init_app_root = __esm({
 
 // src/lib/config/env.ts
 import { homedir } from "os";
-import { join as join3, resolve } from "path";
+import { join as join4, resolve } from "path";
 function dataDir() {
-  return process.env.RELAY_DATA_DIR || join3(homedir(), DEFAULT_DATA_DIR_NAME);
+  return process.env.RELAY_DATA_DIR || join4(homedir(), DEFAULT_DATA_DIR_NAME);
 }
 function dbPath() {
-  return join3(dataDir(), DB_FILENAME);
+  return join4(dataDir(), DB_FILENAME);
 }
 function isPrivateDataDir() {
   const override = process.env.RELAY_DATA_DIR;
   if (!override) return false;
-  return resolve(override) !== resolve(join3(homedir(), DEFAULT_DATA_DIR_NAME));
+  return resolve(override) !== resolve(join4(homedir(), DEFAULT_DATA_DIR_NAME));
 }
 function launchCwd() {
   return process.env.RELAY_LAUNCH_CWD || process.cwd();
@@ -125,7 +125,7 @@ __export(ainative_paths_exports, {
   getAinativeSnapshotsDir: () => getAinativeSnapshotsDir,
   getAinativeUploadsDir: () => getAinativeUploadsDir
 });
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function getAinativeDataDir() {
   return dataDir();
 }
@@ -133,55 +133,55 @@ function getAinativeDbPath() {
   return dbPath();
 }
 function getAinativeUploadsDir() {
-  return join4(getAinativeDataDir(), "uploads");
+  return join5(getAinativeDataDir(), "uploads");
 }
 function getAinativeBlueprintsDir() {
-  return join4(getAinativeDataDir(), "blueprints");
+  return join5(getAinativeDataDir(), "blueprints");
 }
 function getAinativeScreenshotsDir() {
-  return join4(getAinativeDataDir(), "screenshots");
+  return join5(getAinativeDataDir(), "screenshots");
 }
 function getAinativeSnapshotsDir() {
-  return join4(getAinativeDataDir(), "snapshots");
+  return join5(getAinativeDataDir(), "snapshots");
 }
 function getAinativeOutputsDir() {
-  return join4(getAinativeDataDir(), "outputs");
+  return join5(getAinativeDataDir(), "outputs");
 }
 function getAinativeSessionsDir() {
-  return join4(getAinativeDataDir(), "sessions");
+  return join5(getAinativeDataDir(), "sessions");
 }
 function getAinativeLogsDir() {
-  return join4(getAinativeDataDir(), "logs");
+  return join5(getAinativeDataDir(), "logs");
 }
 function getAinativeDocumentsDir() {
-  return join4(getAinativeDataDir(), "documents");
+  return join5(getAinativeDataDir(), "documents");
 }
 function getAinativeCodexDir() {
-  return join4(getAinativeDataDir(), "codex");
+  return join5(getAinativeDataDir(), "codex");
 }
 function getAinativeCodexConfigPath() {
-  return join4(getAinativeCodexDir(), "config.toml");
+  return join5(getAinativeCodexDir(), "config.toml");
 }
 function getAinativeCodexAuthPath() {
-  return join4(getAinativeCodexDir(), "auth.json");
+  return join5(getAinativeCodexDir(), "auth.json");
 }
 function getAinativeProfilesDir() {
-  return join4(getAinativeDataDir(), "profiles");
+  return join5(getAinativeDataDir(), "profiles");
 }
 function getAinativePluginsDir() {
-  return join4(getAinativeDataDir(), "plugins");
+  return join5(getAinativeDataDir(), "plugins");
 }
 function getAinativeAppsDir() {
-  return join4(getAinativeDataDir(), "apps");
+  return join5(getAinativeDataDir(), "apps");
 }
 function getAinativePluginsLockPath() {
-  return join4(getAinativeDataDir(), "plugins.lock");
+  return join5(getAinativeDataDir(), "plugins.lock");
 }
 function getAinativeSchedulesDir() {
-  return join4(getAinativeDataDir(), "schedules");
+  return join5(getAinativeDataDir(), "schedules");
 }
 function getAinativePluginExamplesDir() {
-  return join4(
+  return join5(
     getAppRoot(import.meta.dirname, 3),
     "src",
     "lib",
@@ -1155,12 +1155,12 @@ var init_bootstrap = __esm({
 });
 
 // src/lib/instance/detect.ts
-import { existsSync as existsSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join7 } from "path";
 function isDevMode(cwd = process.cwd()) {
   if (isInstanceModeEnv()) return false;
   if (isDevModeEnv()) return true;
-  if (existsSync4(join6(cwd, ".git", "relay-dev-mode"))) return true;
+  if (existsSync5(join7(cwd, ".git", "relay-dev-mode"))) return true;
   return false;
 }
 function isPrivateInstance() {
@@ -1221,25 +1221,25 @@ var init_types = __esm({
 });
 
 // src/lib/environment/parsers/utils.ts
-import { createHash } from "crypto";
-import { readFileSync as readFileSync3, statSync } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 function computeHash(content) {
   const truncated = content.slice(0, MAX_HASH_BYTES);
-  return createHash("sha256").update(truncated).digest("hex");
+  return createHash2("sha256").update(truncated).digest("hex");
 }
 function safePreview(content) {
   return content.slice(0, MAX_PREVIEW_CHARS).trim();
 }
 function safeStat(path19) {
   try {
-    return statSync(path19);
+    return statSync2(path19);
   } catch {
     return null;
   }
 }
 function safeReadFile(path19) {
   try {
-    return readFileSync3(path19, "utf-8");
+    return readFileSync4(path19, "utf-8");
   } catch {
     return null;
   }
@@ -1344,7 +1344,7 @@ __export(wrap_exports, {
 import fs from "fs";
 import path from "path";
 import { execFileSync } from "child_process";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function logToFile(line) {
   try {
     const logsDir = getAinativeLogsDir();
@@ -1357,9 +1357,9 @@ function logToFile(line) {
   } catch {
   }
 }
-function profilePath(relative) {
-  const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-  return path.join(moduleDir, "profiles", relative);
+function profilePath(relative2) {
+  const moduleDir = path.dirname(fileURLToPath2(import.meta.url));
+  return path.join(moduleDir, "profiles", relative2);
 }
 function readSeatbeltProfile(cap, pluginId) {
   const p = profilePath(`seatbelt-${cap}.sb`);
@@ -3114,7 +3114,7 @@ __export(db_exports, {
 });
 import Database2 from "better-sqlite3";
 import { drizzle } from "drizzle-orm/better-sqlite3";
-import { mkdirSync } from "fs";
+import { mkdirSync as mkdirSync2 } from "fs";
 var dataDir2, dbPath2, sqlite, db;
 var init_db = __esm({
   "src/lib/db/index.ts"() {
@@ -3123,7 +3123,7 @@ var init_db = __esm({
     init_env();
     init_bootstrap();
     dataDir2 = dataDir();
-    mkdirSync(dataDir2, { recursive: true });
+    mkdirSync2(dataDir2, { recursive: true });
     dbPath2 = dbPath();
     sqlite = new Database2(dbPath2);
     sqlite.pragma("journal_mode = WAL");
@@ -3913,7 +3913,7 @@ __export(load_exports, {
   loadLicense: () => loadLicense
 });
 import fs4 from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function assertEnvelope(value, origin) {
   if (!value || typeof value !== "object") {
     throw new LicenseLoadError(`License at ${origin} is not a JSON object.`);
@@ -3957,7 +3957,7 @@ async function loadLicense(urlOrPath) {
     }
     return parse2(await res.text(), urlOrPath);
   }
-  const filePath = urlOrPath.startsWith("file://") ? fileURLToPath2(urlOrPath) : urlOrPath;
+  const filePath = urlOrPath.startsWith("file://") ? fileURLToPath3(urlOrPath) : urlOrPath;
   let text2;
   try {
     text2 = fs4.readFileSync(filePath, "utf-8");
@@ -4227,7 +4227,7 @@ var init_query_builder = __esm({
 });
 
 // src/lib/data/row-hash.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function canonicalizeRowForHash(data, columnNames) {
   const canonical = {};
   for (const name of columnNames) {
@@ -4237,7 +4237,7 @@ function canonicalizeRowForHash(data, columnNames) {
   return JSON.stringify(canonical);
 }
 function hashRowData(data, columnNames) {
-  return createHash2("sha256").update(canonicalizeRowForHash(data, columnNames)).digest("hex");
+  return createHash3("sha256").update(canonicalizeRowForHash(data, columnNames)).digest("hex");
 }
 var init_row_hash = __esm({
   "src/lib/data/row-hash.ts"() {
@@ -5763,24 +5763,24 @@ __export(crypto_exports, {
   getOrCreateKeyfile: () => getOrCreateKeyfile
 });
 import { randomBytes, createCipheriv, createDecipheriv } from "crypto";
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, chmodSync } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync6, mkdirSync as mkdirSync3, chmodSync } from "fs";
+import { join as join8 } from "path";
 function getKeyfilePath() {
-  return join7(dataDir(), ".keyfile");
+  return join8(dataDir(), ".keyfile");
 }
 function getOrCreateKeyfile() {
   const keyfilePath = getKeyfilePath();
-  if (existsSync5(keyfilePath)) {
-    const key2 = readFileSync4(keyfilePath);
+  if (existsSync6(keyfilePath)) {
+    const key2 = readFileSync5(keyfilePath);
     if (key2.length !== KEY_LENGTH) {
       throw new Error(`Invalid keyfile: expected ${KEY_LENGTH} bytes, got ${key2.length}`);
     }
     return key2;
   }
-  const dir = join7(keyfilePath, "..");
-  mkdirSync2(dir, { recursive: true });
+  const dir = join8(keyfilePath, "..");
+  mkdirSync3(dir, { recursive: true });
   const key = randomBytes(KEY_LENGTH);
-  writeFileSync(keyfilePath, key, { mode: 384 });
+  writeFileSync2(keyfilePath, key, { mode: 384 });
   chmodSync(keyfilePath, 384);
   return key;
 }
@@ -6737,18 +6737,18 @@ __export(workspace_context_exports, {
   getLaunchCwd: () => getLaunchCwd,
   getWorkspaceContext: () => getWorkspaceContext
 });
-import { basename, dirname as dirname3 } from "path";
+import { basename as basename2, dirname as dirname3 } from "path";
 import { homedir as homedir4 } from "os";
 import { execFileSync as execFileSync2 } from "child_process";
-import { statSync as statSync2 } from "fs";
-import { join as join8 } from "path";
+import { statSync as statSync3 } from "fs";
+import { join as join9 } from "path";
 function getLaunchCwd() {
   return launchCwd();
 }
 function getWorkspaceContext() {
   const cwd = getLaunchCwd();
   const home = homedir4();
-  const folderName = basename(cwd);
+  const folderName = basename2(cwd);
   const parent = dirname3(cwd);
   const parentPath = parent.startsWith(home) ? "~" + parent.slice(home.length) : parent;
   let gitBranch = null;
@@ -6762,8 +6762,8 @@ function getWorkspaceContext() {
   }
   let isWorktree = false;
   try {
-    const gitPath = join8(cwd, ".git");
-    const stat2 = statSync2(gitPath);
+    const gitPath = join9(cwd, ".git");
+    const stat2 = statSync3(gitPath);
     isWorktree = stat2.isFile();
   } catch {
   }
@@ -7045,12 +7045,12 @@ var init_browser_mcp = __esm({
 
 // src/lib/screenshots/persist.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, unlinkSync } from "fs";
-import { join as join9 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { join as join10 } from "path";
 async function persistScreenshot(base64Data, opts2) {
   const screenshotsDir = getAinativeScreenshotsDir();
   const id = randomUUID3();
-  const originalPath = join9(screenshotsDir, `${id}.png`);
+  const originalPath = join10(screenshotsDir, `${id}.png`);
   let thumbnailPath = null;
   try {
     if (base64Data.length > MAX_BASE64_BYTES) {
@@ -7064,9 +7064,9 @@ async function persistScreenshot(base64Data, opts2) {
     const dimensions = imageSize(new Uint8Array(buffer));
     const width = dimensions.width ?? 0;
     const height = dimensions.height ?? 0;
-    mkdirSync3(screenshotsDir, { recursive: true });
-    writeFileSync2(originalPath, buffer);
-    thumbnailPath = join9(screenshotsDir, `${id}_thumb.png`);
+    mkdirSync4(screenshotsDir, { recursive: true });
+    writeFileSync3(originalPath, buffer);
+    thumbnailPath = join10(screenshotsDir, `${id}_thumb.png`);
     try {
       const sharp = (await import("sharp")).default;
       await sharp(buffer).resize(THUMBNAIL_WIDTH, void 0, { withoutEnlargement: true }).png({ quality: 80 }).toFile(thumbnailPath);
@@ -7131,7 +7131,7 @@ var init_persist = __esm({
 });
 
 // src/lib/usage/pricing-registry.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function buildDefaultProviders() {
   const nowIso = "2026-03-17T00:00:00.000Z";
   return {
@@ -11297,7 +11297,7 @@ var init_schedule_tools = __esm({
 import { z as z13 } from "zod";
 import { eq as eq25, and as and14, desc as desc10 } from "drizzle-orm";
 import { access, stat, copyFile, mkdir } from "fs/promises";
-import { basename as basename2, extname, join as join10 } from "path";
+import { basename as basename3, extname, join as join11 } from "path";
 import crypto4 from "crypto";
 function resolveMimeType(filename) {
   return MIME_TYPES[extname(filename).toLowerCase()] ?? "application/octet-stream";
@@ -11389,14 +11389,14 @@ function documentTools(ctx) {
           await access(args.file_path);
           const stats = await stat(args.file_path);
           if (!stats.isFile()) return err(`Not a file: ${args.file_path}`);
-          const originalName = basename2(args.file_path);
+          const originalName = basename3(args.file_path);
           const mimeType = resolveMimeType(originalName);
           const id = crypto4.randomUUID();
           const ext = extname(originalName);
           const filename = `${id}${ext}`;
           const uploadsDir = getAinativeUploadsDir();
           await mkdir(uploadsDir, { recursive: true });
-          const storagePath = join10(uploadsDir, filename);
+          const storagePath = join11(uploadsDir, filename);
           await copyFile(args.file_path, storagePath);
           const effectiveProjectId = args.projectId ?? ctx.projectId ?? null;
           const now = /* @__PURE__ */ new Date();
@@ -12863,8 +12863,8 @@ var list_fused_profiles_exports = {};
 __export(list_fused_profiles_exports, {
   listFusedProfiles: () => listFusedProfiles
 });
-import { readdirSync, readFileSync as readFileSync5, statSync as statSync3, existsSync as existsSync6 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync4, existsSync as existsSync7 } from "fs";
+import { join as join12 } from "path";
 import { homedir as homedir5 } from "os";
 function parseFrontmatter2(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -12880,15 +12880,15 @@ function parseFrontmatter2(content) {
   return result;
 }
 function loadFilesystemSkills(skillsDir, origin, projectRootDir) {
-  if (!existsSync6(skillsDir)) return [];
+  if (!existsSync7(skillsDir)) return [];
   const profiles = [];
-  for (const entry of readdirSync(skillsDir)) {
-    const skillPath = join11(skillsDir, entry);
+  for (const entry of readdirSync2(skillsDir)) {
+    const skillPath = join12(skillsDir, entry);
     try {
-      if (!statSync3(skillPath).isDirectory()) continue;
-      const skillMdPath = join11(skillPath, "SKILL.md");
-      if (!existsSync6(skillMdPath)) continue;
-      const content = readFileSync5(skillMdPath, "utf8");
+      if (!statSync4(skillPath).isDirectory()) continue;
+      const skillMdPath = join12(skillPath, "SKILL.md");
+      if (!existsSync7(skillMdPath)) continue;
+      const content = readFileSync6(skillMdPath, "utf8");
       const fm = parseFrontmatter2(content);
       if (!fm || !fm.name) {
         console.warn(
@@ -12921,14 +12921,14 @@ function loadFilesystemSkills(skillsDir, origin, projectRootDir) {
   }
   return profiles;
 }
-async function listFusedProfiles(projectDir, userSkillsDir = join11(homedir5(), ".claude", "skills")) {
+async function listFusedProfiles(projectDir, userSkillsDir = join12(homedir5(), ".claude", "skills")) {
   const registry2 = listProfiles();
   const registryIds = new Set(registry2.map((p) => p.id));
   const userSkills = loadFilesystemSkills(userSkillsDir, "filesystem-user", void 0).filter(
     (p) => !registryIds.has(p.id)
   );
   const projectSkills = projectDir ? loadFilesystemSkills(
-    join11(projectDir, ".claude", "skills"),
+    join12(projectDir, ".claude", "skills"),
     "filesystem-project",
     projectDir
   ).filter((p) => !registryIds.has(p.id) && !userSkills.some((u) => u.id === p.id)) : [];
@@ -15604,21 +15604,21 @@ var init_active_skills = __esm({
 });
 
 // src/lib/environment/parsers/skill.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
-import { join as join12, basename as basename3 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
+import { join as join13, basename as basename4 } from "path";
 function parseSkillDir(dirPath, tool, scope, baseDir) {
   const stat2 = safeStat(dirPath);
   if (!stat2?.isDirectory()) return null;
-  const name = basename3(dirPath);
+  const name = basename4(dirPath);
   if (name.startsWith(".")) return null;
   let mainFile = "";
   let content = "";
   try {
-    const files = readdirSync2(dirPath);
+    const files = readdirSync3(dirPath);
     const skillFile = files.find((f) => f === "SKILL.md") || files.find((f) => f.endsWith(".md")) || files[0];
     if (skillFile) {
-      mainFile = join12(dirPath, skillFile);
-      content = readFileSync6(mainFile, "utf-8");
+      mainFile = join13(dirPath, skillFile);
+      content = readFileSync7(mainFile, "utf-8");
     }
   } catch {
     return null;
@@ -15664,8 +15664,8 @@ var init_skill = __esm({
 });
 
 // src/lib/environment/parsers/settings.ts
-import { readdirSync as readdirSync3 } from "fs";
-import { join as join13, basename as basename4 } from "path";
+import { readdirSync as readdirSync4 } from "fs";
+import { join as join14, basename as basename5 } from "path";
 function parseClaudeSettings(filePath, scope, baseDir) {
   const content = safeReadFile(filePath);
   if (!content) return [];
@@ -15679,7 +15679,7 @@ function parseClaudeSettings(filePath, scope, baseDir) {
         tool: "claude-code",
         category: "permission",
         scope,
-        name: `${basename4(filePath, ".json")}-allow`,
+        name: `${basename5(filePath, ".json")}-allow`,
         relPath: filePath.replace(baseDir, "").replace(/^\//, ""),
         absPath: filePath,
         contentHash: computeHash(JSON.stringify(config.permissions.allow)),
@@ -15694,7 +15694,7 @@ function parseClaudeSettings(filePath, scope, baseDir) {
         tool: "claude-code",
         category: "permission",
         scope,
-        name: `${basename4(filePath, ".json")}-deny`,
+        name: `${basename5(filePath, ".json")}-deny`,
         relPath: filePath.replace(baseDir, "").replace(/^\//, ""),
         absPath: filePath,
         contentHash: computeHash(JSON.stringify(config.permissions.deny)),
@@ -15768,8 +15768,8 @@ function parseOutputStyles(dirPath, tool, baseDir) {
   if (!stat2?.isDirectory()) return [];
   const artifacts = [];
   try {
-    for (const entry of readdirSync3(dirPath)) {
-      const fullPath = join13(dirPath, entry);
+    for (const entry of readdirSync4(dirPath)) {
+      const fullPath = join14(dirPath, entry);
       const content = safeReadFile(fullPath);
       if (!content) continue;
       const fStat = safeStat(fullPath);
@@ -15778,7 +15778,7 @@ function parseOutputStyles(dirPath, tool, baseDir) {
         tool,
         category: "output-style",
         scope: "user",
-        name: basename4(entry, ".md"),
+        name: basename5(entry, ".md"),
         relPath: fullPath.replace(baseDir, "").replace(/^\//, ""),
         absPath: fullPath,
         contentHash: computeHash(content),
@@ -15846,18 +15846,18 @@ var init_instructions = __esm({
 });
 
 // src/lib/environment/scanners/claude-code.ts
-import { readdirSync as readdirSync4, existsSync as existsSync7 } from "fs";
-import { join as join14 } from "path";
+import { readdirSync as readdirSync5, existsSync as existsSync8 } from "fs";
+import { join as join15 } from "path";
 function scanUserLevel(userHome) {
-  const claudeDir = join14(userHome, ".claude");
+  const claudeDir = join15(userHome, ".claude");
   const artifacts = [];
   const errors = [];
-  if (!existsSync7(claudeDir)) return { artifacts, errors };
-  const skillsDir = join14(claudeDir, "skills");
-  if (existsSync7(skillsDir)) {
+  if (!existsSync8(claudeDir)) return { artifacts, errors };
+  const skillsDir = join15(claudeDir, "skills");
+  if (existsSync8(skillsDir)) {
     try {
-      for (const entry of readdirSync4(skillsDir)) {
-        const skillPath = join14(skillsDir, entry);
+      for (const entry of readdirSync5(skillsDir)) {
+        const skillPath = join15(skillsDir, entry);
         const artifact = parseSkillDir(skillPath, "claude-code", "user", userHome);
         if (artifact) artifacts.push(artifact);
       }
@@ -15865,32 +15865,32 @@ function scanUserLevel(userHome) {
       errors.push({ path: skillsDir, error: String(e) });
     }
   }
-  const mcpPath = join14(claudeDir, ".mcp.json");
-  if (existsSync7(mcpPath)) {
+  const mcpPath = join15(claudeDir, ".mcp.json");
+  if (existsSync8(mcpPath)) {
     artifacts.push(...parseClaudeMcpConfig(mcpPath, "user", userHome));
   }
-  const pluginsFile = join14(claudeDir, "plugins", "installed_plugins.json");
-  if (existsSync7(pluginsFile)) {
+  const pluginsFile = join15(claudeDir, "plugins", "installed_plugins.json");
+  if (existsSync8(pluginsFile)) {
     artifacts.push(...parseClaudePlugins(pluginsFile, userHome));
   }
   for (const settingsFile of ["settings.json", "settings.local.json"]) {
-    const settingsPath = join14(claudeDir, settingsFile);
-    if (existsSync7(settingsPath)) {
+    const settingsPath = join15(claudeDir, settingsFile);
+    if (existsSync8(settingsPath)) {
       artifacts.push(...parseClaudeSettings(settingsPath, "user", userHome));
     }
   }
-  const outputStylesDir = join14(claudeDir, "output-styles");
-  if (existsSync7(outputStylesDir)) {
+  const outputStylesDir = join15(claudeDir, "output-styles");
+  if (existsSync8(outputStylesDir)) {
     artifacts.push(...parseOutputStyles(outputStylesDir, "claude-code", userHome));
   }
-  const projectsDir = join14(claudeDir, "projects");
-  if (existsSync7(projectsDir)) {
+  const projectsDir = join15(claudeDir, "projects");
+  if (existsSync8(projectsDir)) {
     try {
-      for (const projEntry of readdirSync4(projectsDir)) {
-        const memoryDir = join14(projectsDir, projEntry, "memory");
-        if (!existsSync7(memoryDir)) continue;
-        const memoryIndex = join14(memoryDir, "MEMORY.md");
-        if (existsSync7(memoryIndex)) {
+      for (const projEntry of readdirSync5(projectsDir)) {
+        const memoryDir = join15(projectsDir, projEntry, "memory");
+        if (!existsSync8(memoryDir)) continue;
+        const memoryIndex = join15(memoryDir, "MEMORY.md");
+        if (existsSync8(memoryIndex)) {
           const artifact = parseInstructionFile(
             memoryIndex,
             "user",
@@ -15911,16 +15911,16 @@ function scanUserLevel(userHome) {
   return { artifacts, errors };
 }
 function scanProjectLevel(projectDir) {
-  const claudeDir = join14(projectDir, ".claude");
+  const claudeDir = join15(projectDir, ".claude");
   const artifacts = [];
   const errors = [];
   artifacts.push(...scanInstructionFiles(projectDir, "project", projectDir));
-  if (!existsSync7(claudeDir)) return { artifacts, errors };
-  const skillsDir = join14(claudeDir, "skills");
-  if (existsSync7(skillsDir)) {
+  if (!existsSync8(claudeDir)) return { artifacts, errors };
+  const skillsDir = join15(claudeDir, "skills");
+  if (existsSync8(skillsDir)) {
     try {
-      for (const entry of readdirSync4(skillsDir)) {
-        const skillPath = join14(skillsDir, entry);
+      for (const entry of readdirSync5(skillsDir)) {
+        const skillPath = join15(skillsDir, entry);
         const artifact = parseSkillDir(skillPath, "claude-code", "project", projectDir);
         if (artifact) artifacts.push(artifact);
       }
@@ -15928,21 +15928,21 @@ function scanProjectLevel(projectDir) {
       errors.push({ path: skillsDir, error: String(e) });
     }
   }
-  const mcpPath = join14(claudeDir, ".mcp.json");
-  if (existsSync7(mcpPath)) {
+  const mcpPath = join15(claudeDir, ".mcp.json");
+  if (existsSync8(mcpPath)) {
     artifacts.push(...parseClaudeMcpConfig(mcpPath, "project", projectDir));
   }
   for (const settingsFile of ["settings.json", "settings.local.json"]) {
-    const settingsPath = join14(claudeDir, settingsFile);
-    if (existsSync7(settingsPath)) {
+    const settingsPath = join15(claudeDir, settingsFile);
+    if (existsSync8(settingsPath)) {
       artifacts.push(...parseClaudeSettings(settingsPath, "project", projectDir));
     }
   }
-  const hooksDir = join14(claudeDir, "hooks");
-  if (existsSync7(hooksDir)) {
+  const hooksDir = join15(claudeDir, "hooks");
+  if (existsSync8(hooksDir)) {
     try {
-      for (const entry of readdirSync4(hooksDir)) {
-        const hookPath = join14(hooksDir, entry);
+      for (const entry of readdirSync5(hooksDir)) {
+        const hookPath = join15(hooksDir, entry);
         const content = safeReadFile(hookPath);
         if (!content) continue;
         const stat2 = safeStat(hookPath);
@@ -15987,18 +15987,18 @@ var init_claude_code = __esm({
 });
 
 // src/lib/environment/scanners/codex.ts
-import { readdirSync as readdirSync5, existsSync as existsSync8 } from "fs";
-import { join as join15 } from "path";
+import { readdirSync as readdirSync6, existsSync as existsSync9 } from "fs";
+import { join as join16 } from "path";
 function scanUserLevel2(userHome) {
-  const codexDir = join15(userHome, ".codex");
+  const codexDir = join16(userHome, ".codex");
   const artifacts = [];
   const errors = [];
-  if (!existsSync8(codexDir)) return { artifacts, errors };
-  const skillsDir = join15(codexDir, "skills");
-  if (existsSync8(skillsDir)) {
+  if (!existsSync9(codexDir)) return { artifacts, errors };
+  const skillsDir = join16(codexDir, "skills");
+  if (existsSync9(skillsDir)) {
     try {
-      for (const entry of readdirSync5(skillsDir)) {
-        const skillPath = join15(skillsDir, entry);
+      for (const entry of readdirSync6(skillsDir)) {
+        const skillPath = join16(skillsDir, entry);
         const artifact = parseSkillDir(skillPath, "codex", "user", userHome);
         if (artifact) artifacts.push(artifact);
       }
@@ -16006,16 +16006,16 @@ function scanUserLevel2(userHome) {
       errors.push({ path: skillsDir, error: String(e) });
     }
   }
-  const configPath = join15(codexDir, "config.toml");
-  if (existsSync8(configPath)) {
+  const configPath = join16(codexDir, "config.toml");
+  if (existsSync9(configPath)) {
     artifacts.push(...parseCodexSettings(configPath, userHome));
     artifacts.push(...parseCodexMcpConfig(configPath, userHome));
   }
-  const rulesDir = join15(codexDir, "rules");
-  if (existsSync8(rulesDir)) {
+  const rulesDir = join16(codexDir, "rules");
+  if (existsSync9(rulesDir)) {
     try {
-      for (const entry of readdirSync5(rulesDir)) {
-        const rulePath = join15(rulesDir, entry);
+      for (const entry of readdirSync6(rulesDir)) {
+        const rulePath = join16(rulesDir, entry);
         const content = safeReadFile(rulePath);
         if (!content) continue;
         const stat2 = safeStat(rulePath);
@@ -16038,11 +16038,11 @@ function scanUserLevel2(userHome) {
       errors.push({ path: rulesDir, error: String(e) });
     }
   }
-  const memoriesDir = join15(codexDir, "memories");
-  if (existsSync8(memoriesDir)) {
+  const memoriesDir = join16(codexDir, "memories");
+  if (existsSync9(memoriesDir)) {
     try {
-      for (const entry of readdirSync5(memoriesDir)) {
-        const memPath = join15(memoriesDir, entry);
+      for (const entry of readdirSync6(memoriesDir)) {
+        const memPath = join16(memoriesDir, entry);
         const content = safeReadFile(memPath);
         if (!content) continue;
         const stat2 = safeStat(memPath);
@@ -16070,8 +16070,8 @@ function scanUserLevel2(userHome) {
 function scanProjectLevel2(projectDir) {
   const artifacts = [];
   const errors = [];
-  const codexMd = join15(projectDir, "codex.md");
-  if (existsSync8(codexMd)) {
+  const codexMd = join16(projectDir, "codex.md");
+  if (existsSync9(codexMd)) {
     const artifact = parseInstructionFile(codexMd, "project", projectDir, "codex");
     if (artifact) artifacts.push(artifact);
   }
@@ -16097,13 +16097,13 @@ var init_codex = __esm({
 });
 
 // src/lib/environment/scanner.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join17 } from "path";
 import { homedir as homedir6 } from "os";
 function detectPersonas(userHome, projectDir) {
   const personas = [];
-  const hasClaudeCode = existsSync9(join16(userHome, ".claude")) || existsSync9(join16(projectDir, ".claude"));
-  const hasCodex = existsSync9(join16(userHome, ".codex"));
+  const hasClaudeCode = existsSync10(join17(userHome, ".claude")) || existsSync10(join17(projectDir, ".claude"));
+  const hasCodex = existsSync10(join17(userHome, ".codex"));
   if (hasClaudeCode) personas.push("claude-code");
   if (hasCodex) personas.push("codex");
   return personas;
@@ -16254,8 +16254,8 @@ __export(list_skills_exports, {
   listSkills: () => listSkills,
   listSkillsEnriched: () => listSkillsEnriched
 });
-import { readFileSync as readFileSync7, readdirSync as readdirSync6, statSync as statSync4 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync8, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
+import { join as join18 } from "path";
 function listSkills(options = {}) {
   const projectDir = options.projectDir ?? getLaunchCwd();
   const scan = scanEnvironment({ projectDir });
@@ -16279,7 +16279,7 @@ function getSkill(id, options = {}) {
   const filePath = resolveSkillFile(hit.absPath);
   if (!filePath) return null;
   try {
-    const content = readFileSync7(filePath, "utf8");
+    const content = readFileSync8(filePath, "utf8");
     return { ...hit, content };
   } catch {
     return null;
@@ -16287,7 +16287,7 @@ function getSkill(id, options = {}) {
 }
 function resolveSkillFile(dirPath) {
   try {
-    const stat2 = statSync4(dirPath);
+    const stat2 = statSync5(dirPath);
     if (!stat2.isDirectory()) {
       return dirPath;
     }
@@ -16295,15 +16295,15 @@ function resolveSkillFile(dirPath) {
     return null;
   }
   for (const name of ["SKILL.md", "skill.md"]) {
-    const candidate = join17(dirPath, name);
+    const candidate = join18(dirPath, name);
     try {
-      if (statSync4(candidate).isFile()) return candidate;
+      if (statSync5(candidate).isFile()) return candidate;
     } catch {
     }
   }
   try {
-    const fallback = readdirSync6(dirPath).find((f) => f.toLowerCase().endsWith(".md"));
-    if (fallback) return join17(dirPath, fallback);
+    const fallback = readdirSync7(dirPath).find((f) => f.toLowerCase().endsWith(".md"));
+    if (fallback) return join18(dirPath, fallback);
   } catch {
   }
   return null;
@@ -18704,7 +18704,7 @@ __export(openai_auth_exports, {
   updateOpenAIAuthStatus: () => updateOpenAIAuthStatus,
   updateOpenAIOAuthStatus: () => updateOpenAIOAuthStatus
 });
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 function parseJson(raw) {
   if (!raw) return null;
   try {
@@ -18738,7 +18738,7 @@ async function getOpenAIAuthSettings() {
   } else {
     apiKeySource = "unknown";
   }
-  const oauthConnected = storedOauthConnected === "true" || storedOauthConnected == null && existsSync11(getAinativeCodexAuthPath());
+  const oauthConnected = storedOauthConnected === "true" || storedOauthConnected == null && existsSync12(getAinativeCodexAuthPath());
   return {
     method,
     hasKey: hasDbKey || hasEnvKey,
@@ -18828,13 +18828,13 @@ __export(mcp_sync_exports, {
   preparePluginMcpCodexSync: () => preparePluginMcpCodexSync,
   syncPluginMcpToCodex: () => syncPluginMcpToCodex
 });
-import { writeFileSync as writeFileSync4 } from "fs";
-import { join as join19 } from "path";
+import { writeFileSync as writeFileSync5 } from "fs";
+import { join as join20 } from "path";
 import { homedir as homedir7 } from "os";
 function prepareMcpToClaude(artifact, scope, projectDir) {
   const metadata = artifact.metadata ? JSON.parse(artifact.metadata) : {};
   const serverName = artifact.name;
-  const targetPath = scope === "user" ? join19(homedir7(), ".claude", ".mcp.json") : join19(projectDir || getLaunchCwd(), ".claude", ".mcp.json");
+  const targetPath = scope === "user" ? join20(homedir7(), ".claude", ".mcp.json") : join20(projectDir || getLaunchCwd(), ".claude", ".mcp.json");
   const existing = safeReadFile(targetPath);
   let config;
   try {
@@ -18859,7 +18859,7 @@ function prepareMcpToClaude(artifact, scope, projectDir) {
 function prepareMcpToCodex(artifact) {
   const metadata = artifact.metadata ? JSON.parse(artifact.metadata) : {};
   const serverName = artifact.name;
-  const targetPath = join19(homedir7(), ".codex", "config.toml");
+  const targetPath = join20(homedir7(), ".codex", "config.toml");
   const existing = safeReadFile(targetPath) || "";
   const lines = [];
   lines.push(`[mcp_servers.${serverName}]`);
@@ -18894,7 +18894,7 @@ function prepareMcpSync(artifact, targetTool, scope, projectDir) {
   return prepareMcpToCodex(artifact);
 }
 function preparePluginMcpCodexSync(registrations, targetPath) {
-  const resolvedPath = targetPath ?? join19(homedir7(), ".codex", "config.toml");
+  const resolvedPath = targetPath ?? join20(homedir7(), ".codex", "config.toml");
   const existing = safeReadFile(resolvedPath) || "";
   const pluginKeys = new Set(
     registrations.map((r) => `${r.pluginId}-${r.serverName}`)
@@ -18959,7 +18959,7 @@ async function syncPluginMcpToCodex() {
   const { listPluginMcpRegistrations: listPluginMcpRegistrations2 } = await Promise.resolve().then(() => (init_mcp_loader(), mcp_loader_exports));
   const registrations = await listPluginMcpRegistrations2();
   const op = preparePluginMcpCodexSync(registrations);
-  writeFileSync4(op.targetPath, op.content, "utf8");
+  writeFileSync5(op.targetPath, op.content, "utf8");
 }
 var init_mcp_sync = __esm({
   "src/lib/environment/sync/mcp-sync.ts"() {
@@ -25235,8 +25235,8 @@ import { execFileSync as execFileSync3 } from "child_process";
 import yaml12 from "js-yaml";
 import semver from "semver";
 function relayCoreVersion() {
-  if (semver.valid("0.15.4")) {
-    return "0.15.4";
+  if (semver.valid("0.16.0")) {
+    return "0.16.0";
   }
   try {
     const root = getAppRoot(import.meta.dirname, 3);
@@ -25606,14 +25606,14 @@ var init_cli = __esm({
 
 // bin/cli.ts
 import { program } from "commander";
-import { basename as basename5, dirname as dirname5, join as join20 } from "path";
+import { basename as basename6, dirname as dirname5, join as join21 } from "path";
 import { homedir as homedir8 } from "os";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import {
-  mkdirSync as mkdirSync5,
-  existsSync as existsSync12,
-  readFileSync as readFileSync8,
-  writeFileSync as writeFileSync5,
+  mkdirSync as mkdirSync6,
+  existsSync as existsSync13,
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync6,
   cpSync as cpSync2,
   unlinkSync as unlinkSync2
 } from "fs";
@@ -25685,19 +25685,249 @@ function isNonLoopbackHost(host) {
   return true;
 }
 
+// src/lib/desktop/prebuilt-download.ts
+import { createHash } from "crypto";
+import {
+  copyFileSync,
+  createWriteStream,
+  createReadStream,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, join as join2, relative } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { fileURLToPath } from "url";
+import * as tar from "tar";
+var PrebuiltDownloadError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PrebuiltDownloadError";
+  }
+};
+var RELEASE_DOWNLOAD_BASE = "https://github.com/orionfold/relay/releases/download";
+function artifactFileName(version) {
+  return `relay-next-build-${version}.tgz`;
+}
+function buildArtifactUrl(version, override) {
+  if (override && override.trim()) {
+    return override.trim();
+  }
+  return `${RELEASE_DOWNLOAD_BASE}/v${version}/${artifactFileName(version)}`;
+}
+function artifactCachePaths(buildsDir, version) {
+  const tgz = join2(buildsDir, artifactFileName(version));
+  return { tgz, sha: `${tgz}.sha256` };
+}
+function parseSha256File(text2) {
+  const match = text2.match(/\b[0-9a-f]{64}\b/i);
+  if (!match) {
+    throw new PrebuiltDownloadError(
+      `Checksum file did not contain a sha256 digest: "${text2.slice(0, 80)}"`
+    );
+  }
+  return match[0].toLowerCase();
+}
+async function sha256OfFile(filePath) {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(filePath), hash);
+  return hash.digest("hex");
+}
+async function downloadToFile(url, destPath) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (cause) {
+    throw new PrebuiltDownloadError(`Invalid artifact URL: ${url}`, { cause });
+  }
+  if (parsed.protocol === "file:") {
+    const sourcePath = fileURLToPath(parsed);
+    if (!existsSync2(sourcePath)) {
+      throw new PrebuiltDownloadError(`Artifact not found at ${sourcePath}`);
+    }
+    copyFileSync(sourcePath, destPath);
+    return;
+  }
+  let response;
+  try {
+    response = await fetch(url, { redirect: "follow" });
+  } catch (cause) {
+    throw new PrebuiltDownloadError(
+      `Network error downloading ${url}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+  }
+  if (!response.ok || !response.body) {
+    throw new PrebuiltDownloadError(
+      `Download of ${url} failed with HTTP ${response.status} ${response.statusText}`
+    );
+  }
+  try {
+    await pipeline(
+      Readable.fromWeb(response.body),
+      createWriteStream(destPath)
+    );
+  } catch (cause) {
+    rmSync(destPath, { force: true });
+    throw new PrebuiltDownloadError(
+      `Failed writing artifact to ${destPath}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+  }
+}
+async function extractPrebuilt(tgzPath, destDir) {
+  try {
+    await tar.extract({ file: tgzPath, cwd: destDir, strict: true });
+  } catch (cause) {
+    throw new PrebuiltDownloadError(
+      `Failed extracting ${basename(tgzPath)}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+  }
+  if (!existsSync2(join2(destDir, ".next", "BUILD_ID"))) {
+    throw new PrebuiltDownloadError(
+      `Artifact ${basename(tgzPath)} extracted but contains no .next/BUILD_ID \u2014 not a valid prebuilt bundle.`
+    );
+  }
+  relinkExternalPackages(destDir);
+}
+function relinkExternalPackages(destDir) {
+  const manifestPath = join2(destDir, ".next", "relay-external-packages.json");
+  if (!existsSync2(manifestPath)) {
+    return;
+  }
+  let links;
+  try {
+    links = JSON.parse(readFileSync(manifestPath, "utf-8")).links ?? {};
+  } catch (cause) {
+    throw new PrebuiltDownloadError(
+      `Artifact manifest ${manifestPath} is not valid JSON.`,
+      { cause }
+    );
+  }
+  const linksDir = join2(destDir, ".next", "node_modules");
+  mkdirSync(linksDir, { recursive: true });
+  for (const [hashedName, packagePath] of Object.entries(links)) {
+    const target = join2(destDir, "node_modules", packagePath);
+    if (!existsSync2(target)) {
+      throw new PrebuiltDownloadError(
+        `Prebuilt server expects package "${packagePath}" (as ${hashedName}) but it is not installed at ${target}. The npm install may be incomplete \u2014 reinstall and retry.`
+      );
+    }
+    const linkPath = join2(linksDir, hashedName);
+    rmSync(linkPath, { recursive: true, force: true });
+    try {
+      if (process.platform === "win32") {
+        symlinkSync(target, linkPath, "junction");
+      } else {
+        symlinkSync(relative(linksDir, target), linkPath);
+      }
+    } catch (cause) {
+      throw new PrebuiltDownloadError(
+        `Could not link ${hashedName} \u2192 ${target}: ${cause instanceof Error ? cause.message : String(cause)}`,
+        { cause }
+      );
+    }
+  }
+}
+function pruneBuildCache(buildsDir, currentVersion, keep = 2) {
+  let entries;
+  try {
+    entries = readdirSync(buildsDir).filter(
+      (name) => /^relay-next-build-.+\.tgz$/.test(name)
+    );
+  } catch {
+    return;
+  }
+  const current = artifactFileName(currentVersion);
+  const others = entries.filter((name) => name !== current).map((name) => {
+    const filePath = join2(buildsDir, name);
+    let mtime = 0;
+    try {
+      mtime = statSync(filePath).mtimeMs;
+    } catch {
+    }
+    return { name, filePath, mtime };
+  }).sort((a, b) => b.mtime - a.mtime);
+  const keepOthers = entries.includes(current) ? keep - 1 : keep;
+  for (const stale of others.slice(Math.max(keepOthers, 0))) {
+    rmSync(stale.filePath, { force: true });
+    rmSync(`${stale.filePath}.sha256`, { force: true });
+  }
+}
+async function ensurePrebuilt({
+  version,
+  effectiveCwd,
+  buildsDir,
+  artifactUrlOverride,
+  log
+}) {
+  if (existsSync2(join2(effectiveCwd, ".next", "BUILD_ID"))) {
+    return "already-present";
+  }
+  mkdirSync(buildsDir, { recursive: true });
+  const cache = artifactCachePaths(buildsDir, version);
+  if (existsSync2(cache.tgz) && existsSync2(cache.sha)) {
+    log(`Using cached production build for ${version} (${cache.tgz}).`);
+    await verifyChecksum(cache.tgz, readFileSync(cache.sha, "utf-8"));
+    await extractPrebuilt(cache.tgz, effectiveCwd);
+    return "from-cache";
+  }
+  const url = buildArtifactUrl(version, artifactUrlOverride);
+  log(`Downloading production build for ${version} (~40 MB) from ${url} ...`);
+  try {
+    await downloadToFile(url, cache.tgz);
+    const shaText = await fetchChecksumText(`${url}.sha256`, buildsDir);
+    writeFileSync(cache.sha, shaText, "utf-8");
+    await verifyChecksum(cache.tgz, shaText);
+    await extractPrebuilt(cache.tgz, effectiveCwd);
+  } catch (error) {
+    rmSync(cache.tgz, { force: true });
+    rmSync(cache.sha, { force: true });
+    throw error;
+  }
+  log(`Production build ready (cached at ${cache.tgz}).`);
+  pruneBuildCache(buildsDir, version);
+  return "downloaded";
+}
+async function fetchChecksumText(shaUrl, buildsDir) {
+  const tempPath = join2(buildsDir, `.sha-download-${process.pid}`);
+  try {
+    await downloadToFile(shaUrl, tempPath);
+    return readFileSync(tempPath, "utf-8");
+  } finally {
+    rmSync(tempPath, { force: true });
+  }
+}
+async function verifyChecksum(tgzPath, shaFileText) {
+  const expected = parseSha256File(shaFileText);
+  const actual = await sha256OfFile(tgzPath);
+  if (actual !== expected) {
+    throw new PrebuiltDownloadError(
+      `Checksum mismatch for ${basename(tgzPath)}: expected ${expected}, got ${actual}. The download may be corrupt or tampered with.`
+    );
+  }
+}
+
 // bin/cli.ts
 init_ainative_paths();
 init_bootstrap();
 
 // src/lib/utils/migrate-to-ainative.ts
-import { existsSync as existsSync3, renameSync, cpSync, rmSync, readFileSync as readFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, renameSync, cpSync, rmSync as rmSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join6 } from "path";
 import { homedir as homedir2 } from "os";
 import Database from "better-sqlite3";
 function hasSqliteHeader(path19) {
   const SQLITE_MAGIC = "SQLite format 3\0";
   try {
-    const header = readFileSync2(path19, { encoding: null });
+    const header = readFileSync3(path19, { encoding: null });
     return header.length >= 16 && header.subarray(0, 16).toString("binary") === SQLITE_MAGIC;
   } catch {
     return false;
@@ -25705,7 +25935,7 @@ function hasSqliteHeader(path19) {
 }
 async function migrateLegacyData(options = {}) {
   const home = options.home ?? homedir2();
-  const gitDir = options.gitDir ?? join5(process.cwd(), ".git");
+  const gitDir = options.gitDir ?? join6(process.cwd(), ".git");
   const log = options.logger ?? ((m) => console.log(`[migrate] ${m}`));
   const report = {
     dirMigrated: false,
@@ -25715,9 +25945,9 @@ async function migrateLegacyData(options = {}) {
     keychainMigrated: false,
     errors: []
   };
-  const oldDir = join5(home, ".stagent");
-  const newDir = join5(home, ".ainative");
-  if (existsSync3(oldDir) && !existsSync3(newDir)) {
+  const oldDir = join6(home, ".stagent");
+  const newDir = join6(home, ".ainative");
+  if (existsSync4(oldDir) && !existsSync4(newDir)) {
     try {
       renameSync(oldDir, newDir);
       report.dirMigrated = true;
@@ -25727,7 +25957,7 @@ async function migrateLegacyData(options = {}) {
       if (e.code === "EXDEV") {
         try {
           cpSync(oldDir, newDir, { recursive: true });
-          rmSync(oldDir, { recursive: true, force: true });
+          rmSync2(oldDir, { recursive: true, force: true });
           report.dirMigrated = true;
           log(`copied ${oldDir} -> ${newDir} (cross-device fallback)`);
         } catch (copyErr) {
@@ -25740,11 +25970,11 @@ async function migrateLegacyData(options = {}) {
       }
     }
   }
-  if (existsSync3(newDir)) {
+  if (existsSync4(newDir)) {
     for (const suffix of ["", "-shm", "-wal"]) {
-      const oldName = join5(newDir, `stagent.db${suffix}`);
-      const newName = join5(newDir, `ainative.db${suffix}`);
-      if (existsSync3(oldName) && !existsSync3(newName)) {
+      const oldName = join6(newDir, `stagent.db${suffix}`);
+      const newName = join6(newDir, `ainative.db${suffix}`);
+      if (existsSync4(oldName) && !existsSync4(newName)) {
         try {
           renameSync(oldName, newName);
           report.dbFilesRenamed++;
@@ -25754,11 +25984,11 @@ async function migrateLegacyData(options = {}) {
       }
     }
   }
-  const dbPath4 = join5(newDir, "ainative.db");
-  if (existsSync3(dbPath4) && !hasSqliteHeader(dbPath4)) {
+  const dbPath4 = join6(newDir, "ainative.db");
+  if (existsSync4(dbPath4) && !hasSqliteHeader(dbPath4)) {
     log(`skipping SQL migration \u2014 ${dbPath4} exists but lacks SQLite header`);
   }
-  if (existsSync3(dbPath4) && hasSqliteHeader(dbPath4)) {
+  if (existsSync4(dbPath4) && hasSqliteHeader(dbPath4)) {
     try {
       const db3 = new Database(dbPath4);
       try {
@@ -25789,10 +26019,10 @@ async function migrateLegacyData(options = {}) {
       report.errors.push(`SQL migration failed: ${String(err2)}`);
     }
   }
-  if (existsSync3(gitDir)) {
-    const oldSentinel = join5(gitDir, "stagent-dev-mode");
-    const newSentinel = join5(gitDir, "ainative-dev-mode");
-    if (existsSync3(oldSentinel) && !existsSync3(newSentinel)) {
+  if (existsSync4(gitDir)) {
+    const oldSentinel = join6(gitDir, "stagent-dev-mode");
+    const newSentinel = join6(gitDir, "ainative-dev-mode");
+    if (existsSync4(oldSentinel) && !existsSync4(newSentinel)) {
       try {
         renameSync(oldSentinel, newSentinel);
         report.sentinelRenamed = true;
@@ -25819,16 +26049,16 @@ async function migrateLegacyData(options = {}) {
 
 // bin/cli.ts
 init_detect();
-var __dirname = dirname5(fileURLToPath3(import.meta.url));
-var appDir = join20(__dirname, "..");
+var __dirname = dirname5(fileURLToPath4(import.meta.url));
+var appDir = join21(__dirname, "..");
 var launchCwd2 = process.cwd();
-var _envLocalPath = join20(launchCwd2, ".env.local");
-var _firstRunNeedsEnv = !existsSync12(_envLocalPath) && !process.env.RELAY_DATA_DIR && !isDevMode(launchCwd2);
+var _envLocalPath = join21(launchCwd2, ".env.local");
+var _firstRunNeedsEnv = !existsSync13(_envLocalPath) && !process.env.RELAY_DATA_DIR && !isDevMode(launchCwd2);
 if (_firstRunNeedsEnv) {
-  const folderName = basename5(launchCwd2);
-  const autoDataDir = join20(homedir8(), `.${folderName}`);
+  const folderName = basename6(launchCwd2);
+  const autoDataDir = join21(homedir8(), `.${folderName}`);
   try {
-    writeFileSync5(
+    writeFileSync6(
       _envLocalPath,
       `# Auto-created by orionfold-relay on first run.
 # Points this folder's install at an isolated data directory.
@@ -25850,8 +26080,8 @@ Continuing with the default data directory (~/.relay). This folder will not get
     }
   }
 }
-if (existsSync12(_envLocalPath)) {
-  for (const line of readFileSync8(_envLocalPath, "utf-8").split("\n")) {
+if (existsSync13(_envLocalPath)) {
+  for (const line of readFileSync9(_envLocalPath, "utf-8").split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
     const eqIdx = trimmed.indexOf("=");
@@ -25863,7 +26093,7 @@ if (existsSync12(_envLocalPath)) {
     }
   }
 }
-var pkg = JSON.parse(readFileSync8(join20(appDir, "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync9(join21(appDir, "package.json"), "utf-8"));
 function getHelpText() {
   const dir = getAinativeDataDir();
   const db3 = getAinativeDbPath();
@@ -25871,8 +26101,8 @@ function getHelpText() {
 Data:
   Directory        ${dir}
   Database         ${db3}
-  Sessions         ${join20(dir, "sessions")}
-  Logs             ${join20(dir, "logs")}
+  Sessions         ${join21(dir, "sessions")}
+  Logs             ${join21(dir, "logs")}
 
 Environment variables:
   RELAY_DATA_DIR   Custom data directory for the web app
@@ -25938,15 +26168,15 @@ var requestedPort = Number.parseInt(opts.port, 10);
 if (Number.isNaN(requestedPort) || requestedPort <= 0) {
   program.error(`Invalid port: ${opts.port}`);
 }
-for (const dir of [DATA_DIR, join20(DATA_DIR, "logs"), join20(DATA_DIR, "sessions")]) {
-  mkdirSync5(dir, { recursive: true });
+for (const dir of [DATA_DIR, join21(DATA_DIR, "logs"), join21(DATA_DIR, "sessions")]) {
+  mkdirSync6(dir, { recursive: true });
 }
 if (opts.reset) {
-  if (existsSync12(dbPath3)) {
+  if (existsSync13(dbPath3)) {
     unlinkSync2(dbPath3);
     for (const suffix of ["-wal", "-shm"]) {
       const filePath = dbPath3 + suffix;
-      if (existsSync12(filePath)) unlinkSync2(filePath);
+      if (existsSync13(filePath)) unlinkSync2(filePath);
     }
     console.log("Database reset.");
   } else {
@@ -25956,7 +26186,7 @@ if (opts.reset) {
 var sqlite2 = new Database3(dbPath3);
 sqlite2.pragma("journal_mode = WAL");
 sqlite2.pragma("foreign_keys = ON");
-var migrationsDir = join20(appDir, "src", "lib", "db", "migrations");
+var migrationsDir = join21(appDir, "src", "lib", "db", "migrations");
 var db2 = drizzle2(sqlite2);
 var needsLegacyRecovery = hasLegacyTables(sqlite2) && !hasMigrationHistory(sqlite2);
 if (needsLegacyRecovery) {
@@ -25987,17 +26217,17 @@ async function main() {
     findAvailablePort
   });
   let effectiveCwd = appDir;
-  const localNm = join20(appDir, "node_modules");
-  if (!existsSync12(join20(localNm, "next", "package.json"))) {
+  const localNm = join21(appDir, "node_modules");
+  if (!existsSync13(join21(localNm, "next", "package.json"))) {
     let searchDir = dirname5(appDir);
     while (searchDir !== dirname5(searchDir)) {
-      const candidate = join20(searchDir, "node_modules", "next", "package.json");
-      if (existsSync12(candidate)) {
+      const candidate = join21(searchDir, "node_modules", "next", "package.json");
+      if (existsSync13(candidate)) {
         const hoistedRoot = searchDir;
         for (const name of ["src", "public"]) {
-          const dest = join20(hoistedRoot, name);
-          const src = join20(appDir, name);
-          if (!existsSync12(dest) && existsSync12(src)) {
+          const dest = join21(hoistedRoot, name);
+          const src = join21(appDir, name);
+          if (!existsSync13(dest) && existsSync13(src)) {
             cpSync2(src, dest, { recursive: true });
           }
         }
@@ -26009,10 +26239,10 @@ async function main() {
           "components.json",
           "drizzle.config.ts"
         ]) {
-          const dest = join20(hoistedRoot, name);
-          const src = join20(appDir, name);
-          if (!existsSync12(dest) && existsSync12(src)) {
-            writeFileSync5(dest, readFileSync8(src));
+          const dest = join21(hoistedRoot, name);
+          const src = join21(appDir, name);
+          if (!existsSync13(dest) && existsSync13(src)) {
+            writeFileSync6(dest, readFileSync9(src));
           }
         }
         effectiveCwd = hoistedRoot;
@@ -26021,8 +26251,25 @@ async function main() {
       searchDir = dirname5(searchDir);
     }
   }
+  if (!existsSync13(join21(effectiveCwd, ".next", "BUILD_ID")) && !isDevMode(launchCwd2)) {
+    try {
+      await ensurePrebuilt({
+        version: pkg.version,
+        effectiveCwd,
+        buildsDir: join21(DATA_DIR, "builds"),
+        artifactUrlOverride: process.env.RELAY_BUILD_ARTIFACT_URL,
+        log: (message) => console.log(message)
+      });
+    } catch (e) {
+      const reason = e instanceof Error ? e.message : String(e);
+      console.warn(
+        `\u26A0 Could not set up the production build (${reason}).
+Falling back to development mode for this run \u2014 Relay still works, but slower and with dev-mode console noise. Check your network (the build downloads once per version from GitHub Releases) and re-run, or set RELAY_BUILD_ARTIFACT_URL to a mirror.`
+      );
+    }
+  }
   const nextEntrypoint = resolveNextEntrypoint(effectiveCwd);
-  const isPrebuilt = existsSync12(join20(effectiveCwd, ".next", "BUILD_ID"));
+  const isPrebuilt = existsSync13(join21(effectiveCwd, ".next", "BUILD_ID"));
   const bindHost = opts.hostname || "127.0.0.1";
   if (isNonLoopbackHost(bindHost)) {
     console.warn(
@@ -26049,7 +26296,13 @@ async function main() {
       RELAY_DATA_DIR: DATA_DIR,
       RELAY_LAUNCH_CWD: launchCwd2,
       PORT: String(actualPort),
-      ...opts.safeMode ? { RELAY_SAFE_MODE: "true" } : {}
+      ...opts.safeMode ? { RELAY_SAFE_MODE: "true" } : {},
+      // In dev mode, Next blocks cross-origin /_next/* dev-asset requests from
+      // the LAN client's IP, breaking the app over the network (issue #13).
+      // When the operator has opted into non-loopback binding, tell next.config
+      // to allow any dev origin. Mirrors the same trust decision as the warning
+      // above; harmless for the prebuilt `next start` path (no dev-origin gate).
+      ...isNonLoopbackHost(bindHost) ? { RELAY_ALLOW_LAN_ORIGINS: "true" } : {}
     }
   });
   if (opts.open !== false) {