agentful 0.4.11 → 0.4.14

package/dist/index.cjs

@@ -1904,10 +1904,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         args = args.slice();
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
-        function findFile(baseDir, baseName) {
-          const localBin = path.resolve(baseDir, baseName);
+        function findFile(baseDir, baseName2) {
+          const localBin = path.resolve(baseDir, baseName2);
           if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path.extname(baseName))) return void 0;
+          if (sourceExt.includes(path.extname(baseName2))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs.existsSync(`${localBin}${ext}`)
           );
@@ -3044,7 +3044,7 @@ var VERSION, brand, useColor, wrap, paint, tuiDesign, sym, ui;
 var init_branding = __esm({
   "src/branding.ts"() {
     "use strict";
-    VERSION = "0.4.11" ? "0.4.11" : null.version;
+    VERSION = "0.4.14" ? "0.4.14" : null.version;
     brand = {
       name: "agentful",
       // the command users type
@@ -4015,7 +4015,7 @@ var PB_URL = (process.env.AGENTFUL_PB_URL || "https://pb.agentful.dev").replace(
 var API_URL = (process.env.AGENTFUL_API_URL || PB_URL).replace(/\/$/, "");
 var APP_URL = (process.env.AGENTFUL_APP_URL || "https://app.agentful.dev").replace(/\/$/, "");
 var PUBLIC_API_URL = (process.env.AGENTFUL_PUBLIC_API_URL || "https://api.agentful.dev").replace(/\/$/, "");
-var PREVIEW_DOMAIN = "agentful.dev";
+var PREVIEW_DOMAIN = "agentful.page";
 var PUBLISHED_DOMAIN = "agentful.page";
 function configDir() {
   if (process.platform === "win32" && process.env.APPDATA) {
@@ -5539,102 +5539,6 @@ function zipSync(data, opts) {
 
 // src/lib/zip.ts
 var import_ignore = __toESM(require_ignore());
-var MAX_ZIP_BYTES = 6 * 1024 * 1024;
-var ALWAYS_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  ".agentful",
-  ".opencode",
-  ".cache",
-  "__macosx",
-  "dist",
-  "build",
-  "out",
-  ".next",
-  ".output",
-  ".svelte-kit",
-  ".astro",
-  ".vercel",
-  ".netlify"
-]);
-var ALWAYS_EXCLUDE_BASENAMES = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
-var isEnvFile = (name) => name === ".env" || name.startsWith(".env.");
-function collectFiles(rootDir, mode) {
-  const ig = (0, import_ignore.default)();
-  if (mode === "source") {
-    const gitignorePath = (0, import_node_path6.join)(rootDir, ".gitignore");
-    if ((0, import_node_fs4.existsSync)(gitignorePath)) {
-      ig.add((0, import_node_fs4.readFileSync)(gitignorePath, "utf8"));
-    }
-  }
-  const results = [];
-  const walk = (dir) => {
-    for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
-      const abs = (0, import_node_path6.join)(dir, entry.name);
-      const rel = (0, import_node_path6.relative)(rootDir, abs).split(import_node_path6.sep).join("/");
-      const lower = entry.name.toLowerCase();
-      if (entry.isSymbolicLink()) continue;
-      if (entry.isDirectory()) {
-        if (mode === "source" && (ALWAYS_EXCLUDE_DIRS.has(lower) || ig.ignores(rel + "/"))) continue;
-        walk(abs);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      if (ALWAYS_EXCLUDE_BASENAMES.has(lower)) continue;
-      if (mode === "source") {
-        if (isEnvFile(entry.name)) continue;
-        if (ig.ignores(rel)) continue;
-      }
-      results.push({ rel, abs });
-    }
-  };
-  walk(rootDir);
-  return results;
-}
-function zipToBase64(files) {
-  if (files.length === 0) {
-    throw new ApiError(0, "empty_project", "Nothing to push \u2014 no files found after applying ignore rules.");
-  }
-  const entries = {};
-  for (const f of files) {
-    entries[f.rel] = (0, import_node_fs4.readFileSync)(f.abs);
-  }
-  const zipped = zipSync(entries, { level: 6 });
-  if (zipped.byteLength > MAX_ZIP_BYTES) {
-    throw new ApiError(
-      0,
-      "zip_too_large",
-      `Project zip is ${(zipped.byteLength / 1024 / 1024).toFixed(1)} MB \u2014 the push cap is ${MAX_ZIP_BYTES / 1024 / 1024} MB. Check for large media/binary files; assets belong in the platform asset flow.`
-    );
-  }
-  return {
-    base64: Buffer.from(zipped).toString("base64"),
-    bytes: zipped.byteLength,
-    count: files.length
-  };
-}
-function detectDistDir(rootDir, override) {
-  if (override) {
-    const dir = (0, import_node_path6.join)(rootDir, override);
-    if (!(0, import_node_fs4.existsSync)(dir) || !(0, import_node_fs4.statSync)(dir).isDirectory()) {
-      throw new ApiError(0, "dist_not_found", `--dir ${override} does not exist or is not a directory.`);
-    }
-    return dir;
-  }
-  for (const candidate of ["dist", "build", "out", (0, import_node_path6.join)(".output", "public")]) {
-    const dir = (0, import_node_path6.join)(rootDir, candidate);
-    if ((0, import_node_fs4.existsSync)((0, import_node_path6.join)(dir, "index.html"))) return dir;
-  }
-  throw new ApiError(
-    0,
-    "dist_not_found",
-    "No built output found (looked for dist/, build/, out/, .output/public with an index.html). Run your build first or pass --dir <path>."
-  );
-}
-
-// src/lib/preflight.ts
-var import_node_fs6 = require("fs");
-var import_node_path8 = require("path");
 
 // ../platform-contract/contract.json
 var contract_default = {
@@ -5874,9 +5778,350 @@ var contract_default = {
   }
 };
 
-// ../platform-contract/buildEnv.ts
+// src/lib/uploadLimits.ts
+var MAX_ZIP_UPLOAD_BYTES = contract_default.limits.max_zip_upload_bytes;
+var MAX_UNPACKED_BYTES = 25 * 1024 * 1024;
+var MAX_UPLOAD_FILES = 2e3;
+var MAX_INLINE_REQUEST_BYTES = 6 * 1024 * 1024 - 64 * 1024;
+function uploadRequestBody(zipBase64, mode, declaration) {
+  return { zip_base64: zipBase64, mode, clean: true, ...declaration ? { backend_declaration: declaration } : {} };
+}
+function maxZipBytesForUpload(mode = "source", declaration = null) {
+  const around = Buffer.byteLength(JSON.stringify(uploadRequestBody("", mode, declaration)), "utf8");
+  const base64Budget = Math.max(0, MAX_INLINE_REQUEST_BYTES - around);
+  return Math.min(MAX_ZIP_UPLOAD_BYTES, Math.floor(base64Budget / 4) * 3);
+}
+var SERVER_SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".opencode",
+  ".cache",
+  "__macosx",
+  ".svelte-kit",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".astro",
+  ".vercel",
+  ".netlify",
+  ".wrangler",
+  ".turbo",
+  "dist",
+  "build",
+  "out"
+]);
+var SERVER_SKIP_BASENAMES = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
+var SERVER_SECRET_MARKERS = [
+  ".server/secrets/",
+  "/secrets/",
+  "secrets/",
+  ".git/",
+  "node_modules/",
+  "opencode-logs/",
+  ".opencode/"
+];
+var isMacosMetadata = (rel) => {
+  const lowered = rel.toLowerCase();
+  if (lowered === "__macosx" || lowered.startsWith("__macosx/")) return true;
+  return rel.slice(rel.lastIndexOf("/") + 1).startsWith("._");
+};
+function secretMatch(rel) {
+  const base = rel.slice(rel.lastIndexOf("/") + 1);
+  if (base === ".env" || base.startsWith(".env.") || base.endsWith(".env")) return { reason: "env_file", matched: base };
+  const lowered = rel.toLowerCase();
+  if (lowered.startsWith("knowledge/")) return { reason: "secret_path", matched: "knowledge/" };
+  const marker = SERVER_SECRET_MARKERS.find((m) => lowered.includes(m));
+  return marker ? { reason: "secret_path", matched: marker } : null;
+}
+function serverView(rels) {
+  const topLevels = /* @__PURE__ */ new Set();
+  let nested = false;
+  for (const rel of rels) {
+    if (isMacosMetadata(rel)) continue;
+    const slash = rel.indexOf("/");
+    topLevels.add(slash === -1 ? rel : rel.slice(0, slash));
+    if (slash !== -1) nested = true;
+  }
+  const strippedPrefix = topLevels.size === 1 && nested ? `${[...topLevels][0]}/` : "";
+  const stored = /* @__PURE__ */ new Map();
+  const dropped = [];
+  for (const rel of rels) {
+    if (isMacosMetadata(rel)) {
+      dropped.push({ rel, reason: "macos_metadata", matched: rel.slice(rel.lastIndexOf("/") + 1) });
+      continue;
+    }
+    const inner = strippedPrefix && rel.startsWith(strippedPrefix) ? rel.slice(strippedPrefix.length) : rel;
+    if (!inner) continue;
+    const parts = inner.split("/");
+    const skippedDir = parts.slice(0, -1).find((part) => SERVER_SKIP_DIRS.has(part.toLowerCase()));
+    if (skippedDir) {
+      dropped.push({ rel, reason: "skipped_directory", matched: `${skippedDir}/` });
+      continue;
+    }
+    const base = parts[parts.length - 1];
+    if (SERVER_SKIP_BASENAMES.has(base.toLowerCase())) {
+      dropped.push({ rel, reason: "junk_file", matched: base });
+      continue;
+    }
+    const secret = secretMatch(inner);
+    if (secret) {
+      dropped.push({ rel, ...secret });
+      continue;
+    }
+    stored.set(rel, inner);
+  }
+  return { strippedPrefix, stored, dropped };
+}
+
+// src/lib/zip.ts
+var ZIP_LEVEL = 6;
+var ALWAYS_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".agentful",
+  ".opencode",
+  ".cache",
+  "__macosx",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".output",
+  ".svelte-kit",
+  ".astro",
+  ".vercel",
+  ".netlify"
+]);
+var ALWAYS_EXCLUDE_BASENAMES = /* @__PURE__ */ new Set([".ds_store", "thumbs.db"]);
+var isEnvFile = (name) => name === ".env" || name.startsWith(".env.");
+function scanTree(rootDir, mode) {
+  const ig = (0, import_ignore.default)();
+  let gitignoreApplied = false;
+  if (mode === "source") {
+    const gitignorePath = (0, import_node_path6.join)(rootDir, ".gitignore");
+    if ((0, import_node_fs4.existsSync)(gitignorePath)) {
+      ig.add((0, import_node_fs4.readFileSync)(gitignorePath, "utf8"));
+      gitignoreApplied = true;
+    }
+  }
+  const files = [];
+  const excluded = [];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs4.readdirSync)(dir, { withFileTypes: true })) {
+      const abs = (0, import_node_path6.join)(dir, entry.name);
+      const rel = (0, import_node_path6.relative)(rootDir, abs).split(import_node_path6.sep).join("/");
+      const lower = entry.name.toLowerCase();
+      if (entry.isSymbolicLink()) {
+        excluded.push({ rel, kind: "symlink", reason: "symlink" });
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (mode === "source" && ALWAYS_EXCLUDE_DIRS.has(lower)) {
+          excluded.push({ rel, kind: "dir", reason: "always_excluded_dir" });
+          continue;
+        }
+        if (mode === "source" && ig.ignores(rel + "/")) {
+          excluded.push({ rel, kind: "dir", reason: "gitignore" });
+          continue;
+        }
+        walk(abs);
+        continue;
+      }
+      if (!entry.isFile()) {
+        excluded.push({ rel, kind: "other", reason: "not_a_regular_file" });
+        continue;
+      }
+      if (ALWAYS_EXCLUDE_BASENAMES.has(lower)) {
+        excluded.push({ rel, kind: "file", reason: "os_junk" });
+        continue;
+      }
+      if (mode === "source") {
+        if (isEnvFile(entry.name)) {
+          excluded.push({ rel, kind: "file", reason: "env_file" });
+          continue;
+        }
+        if (ig.ignores(rel)) {
+          excluded.push({ rel, kind: "file", reason: "gitignore" });
+          continue;
+        }
+      }
+      files.push({ rel, abs });
+    }
+  };
+  walk(rootDir);
+  return { files, excluded, gitignoreApplied };
+}
+function collectFiles(rootDir, mode) {
+  return scanTree(rootDir, mode).files;
+}
+function zipToBase64(files, maxBytes = maxZipBytesForUpload()) {
+  if (files.length === 0) {
+    throw new ApiError(0, "empty_project", "Nothing to push \u2014 no files found after applying ignore rules.");
+  }
+  const entries = {};
+  for (const f of files) {
+    entries[f.rel] = (0, import_node_fs4.readFileSync)(f.abs);
+  }
+  const zipped = zipSync(entries, { level: ZIP_LEVEL });
+  if (zipped.byteLength > maxBytes) {
+    throw new ApiError(
+      0,
+      "zip_too_large",
+      `The upload is ${zipped.byteLength.toLocaleString("en-US")} bytes compressed \u2014 a push carries at most ${maxBytes.toLocaleString("en-US")}. \`agentful push --dry-run\` shows what takes the space.`
+    );
+  }
+  return {
+    base64: Buffer.from(zipped).toString("base64"),
+    bytes: zipped.byteLength,
+    count: files.length
+  };
+}
+function detectDistDir(rootDir, override) {
+  if (override) {
+    const dir = (0, import_node_path6.join)(rootDir, override);
+    if (!(0, import_node_fs4.existsSync)(dir) || !(0, import_node_fs4.statSync)(dir).isDirectory()) {
+      throw new ApiError(0, "dist_not_found", `--dir ${override} does not exist or is not a directory.`);
+    }
+    return dir;
+  }
+  for (const candidate of ["dist", "build", "out", (0, import_node_path6.join)(".output", "public")]) {
+    const dir = (0, import_node_path6.join)(rootDir, candidate);
+    if ((0, import_node_fs4.existsSync)((0, import_node_path6.join)(dir, "index.html"))) return dir;
+  }
+  throw new ApiError(
+    0,
+    "dist_not_found",
+    "No built output found (looked for dist/, build/, out/, .output/public with an index.html). Run your build first or pass --dir <path>."
+  );
+}
+
+// src/lib/pushAnalysis.ts
+var import_node_crypto = require("crypto");
+var import_node_fs8 = require("fs");
+var import_node_path10 = require("path");
+init_branding();
+
+// src/lib/backendDecl.ts
 var import_node_fs5 = require("fs");
 var import_node_path7 = require("path");
+function readBackendDeclaration(dir = process.cwd()) {
+  const path = (0, import_node_path7.join)(dir, ".agentful", "backend.json");
+  if (!(0, import_node_fs5.existsSync)(path)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const collections = Array.isArray(parsed.collections) ? parsed.collections.filter((c) => c && typeof c === "object" && !Array.isArray(c)) : [];
+    const secrets = Array.isArray(parsed.secrets) ? parsed.secrets.filter((s) => s && typeof s === "object" && !Array.isArray(s)) : [];
+    const auth = parsed.auth && typeof parsed.auth === "object" && !Array.isArray(parsed.auth) ? parsed.auth : void 0;
+    const decl = {
+      ...parsed,
+      schema_version: Number(parsed.schema_version) || 1,
+      managed_db: Boolean(parsed.managed_db),
+      actions: Array.isArray(parsed.actions) ? parsed.actions.filter((a) => typeof a === "string") : [],
+      contract_doc: typeof parsed.contract_doc === "string" ? parsed.contract_doc : void 0,
+      collections,
+      secrets,
+      auth
+    };
+    const loginMethods = authMethodsOf(decl);
+    if (!decl.managed_db && decl.actions.length === 0 && collections.length === 0 && secrets.length === 0 && loginMethods.length === 0) {
+      return null;
+    }
+    return decl;
+  } catch {
+    return null;
+  }
+}
+function authMethodsOf(decl) {
+  const raw = decl?.auth?.end_user_login;
+  return Array.isArray(raw) ? raw.filter((m) => typeof m === "string") : [];
+}
+function describeBackendDeclaration(decl) {
+  const parts = [];
+  const collections = decl.collections ?? [];
+  if (decl.managed_db || collections.length > 0) {
+    parts.push(collections.length > 0 ? `managed DB with ${collections.length} collection(s)` : "managed DB");
+  }
+  if (decl.actions && decl.actions.length > 0) parts.push(`${decl.actions.length} server action(s)`);
+  if (decl.secrets && decl.secrets.length > 0) parts.push(`${decl.secrets.length} secret(s)`);
+  const login = authMethodsOf(decl);
+  if (login.length > 0) parts.push(`login: ${login.join(" + ")}`);
+  const base = parts.join(" + ") || "managed backend";
+  return decl.contract_doc ? `${base} (contract: ${decl.contract_doc})` : base;
+}
+function backendTabUrl(userId, projectId) {
+  return `${APP_URL}/workspace/${userId}/${projectId}?view=backend`;
+}
+var ACTIONS_DIR = (0, import_node_path7.join)(".server", "actions");
+var ACTION_NAME = /^[a-z][a-z0-9_-]{0,62}$/;
+function checkBackendDeclaration(rootDir = process.cwd()) {
+  const issues = [];
+  const warnings = [];
+  const actionsDir = (0, import_node_path7.join)(rootDir, ACTIONS_DIR);
+  const presentFiles = /* @__PURE__ */ new Set();
+  if ((0, import_node_fs5.existsSync)(actionsDir)) {
+    for (const entry of (0, import_node_fs5.readdirSync)(actionsDir)) {
+      const abs = (0, import_node_path7.join)(actionsDir, entry);
+      let isDir = false;
+      try {
+        isDir = (0, import_node_fs5.statSync)(abs).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) {
+        issues.push(
+          `.server/actions/${entry}/ is a directory \u2014 action files must live directly under .server/actions/ (the platform rejects subdirectories).`
+        );
+        continue;
+      }
+      presentFiles.add(entry);
+      const name = entry.endsWith(".js") ? entry.slice(0, -3) : null;
+      if (name === null || !ACTION_NAME.test(name)) {
+        issues.push(
+          `.server/actions/${entry}: invalid action filename \u2014 must match [a-z][a-z0-9_-]{0,62}.js (names starting with _ are reserved). The platform rejects the whole push otherwise.`
+        );
+      }
+    }
+  }
+  const decl = readBackendDeclaration(rootDir);
+  const declared = decl?.actions ?? [];
+  for (const name of declared) {
+    if (!ACTION_NAME.test(name)) {
+      issues.push(
+        `.agentful/backend.json declares action "${name}" \u2014 names must match [a-z][a-z0-9_-]{0,62} (the filename without .js).`
+      );
+      continue;
+    }
+    if (!presentFiles.has(`${name}.js`)) {
+      issues.push(
+        `.agentful/backend.json declares action "${name}" but .server/actions/${name}.js does not exist \u2014 create the file or remove the declaration entry.`
+      );
+    }
+  }
+  const declaredSet = new Set(declared);
+  for (const file of presentFiles) {
+    const name = file.endsWith(".js") ? file.slice(0, -3) : file;
+    if (ACTION_NAME.test(name) && !declaredSet.has(name)) {
+      warnings.push(
+        `.server/actions/${file} is not declared in .agentful/backend.json \u2014 it will deploy, but \`agentful backend\` and the Backend tab won't know about it. Add "${name}" to the actions list.`
+      );
+    }
+  }
+  if (decl && decl.schema_version < 2 && ((decl.collections?.length ?? 0) > 0 || (decl.secrets?.length ?? 0) > 0 || authMethodsOf(decl).length > 0)) {
+    issues.push(
+      '.agentful/backend.json declares collections/secrets/auth but has "schema_version": 1 \u2014 set it to 2 (schema_version 1 declares actions only).'
+    );
+  }
+  return { issues, warnings };
+}
+
+// src/lib/preflight.ts
+var import_node_fs7 = require("fs");
+var import_node_path9 = require("path");
+
+// ../platform-contract/buildEnv.ts
+var import_node_fs6 = require("fs");
+var import_node_path8 = require("path");
 var BUILD_ENV = contract_default.publish.build_env;
 var PUBLIC_PREFIXES = BUILD_ENV.public_prefixes;
 var BUILTINS = new Set(BUILD_ENV.bundler_builtins);
@@ -5907,10 +6152,10 @@ var MENTIONS_ENV = /\benv\s*[.[]/;
 var stripNonCode = (text) => text.replace(QUOTED, (quoted) => MENTIONS_ENV.test(quoted) ? "''" : quoted).replace(/\/\*[\s\S]*?\*\//g, " ").replace(/(^|[^:'"`\\])\/\/[^\n]*/g, "$1");
 var isReportable = (name) => !BUILTINS.has(name) && splitName(name) !== null;
 function collectFiles2(dir, out, budget) {
-  if (budget.left <= 0 || !(0, import_node_fs5.existsSync)(dir)) return;
-  for (const entry of (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true })) {
+  if (budget.left <= 0 || !(0, import_node_fs6.existsSync)(dir)) return;
+  for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true })) {
     if (budget.left <= 0) return;
-    const abs = (0, import_node_path7.join)(dir, entry.name);
+    const abs = (0, import_node_path8.join)(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name)) collectFiles2(abs, out, budget);
     } else if (entry.isFile() && SCAN_FILE.test(entry.name) && !SKIP_FILE.test(entry.name)) {
@@ -5926,7 +6171,7 @@ function scanEnvReads(rootDir) {
   for (const abs of files) {
     let text;
     try {
-      text = (0, import_node_fs5.readFileSync)(abs, "utf8");
+      text = (0, import_node_fs6.readFileSync)(abs, "utf8");
     } catch {
       continue;
     }
@@ -5943,19 +6188,19 @@ function scanEnvReads(rootDir) {
         if (field) note(field[1], Boolean(field[2]));
       }
     }
-    const file = (0, import_node_path7.relative)(rootDir, abs).split(import_node_path7.sep).join("/");
+    const file = (0, import_node_path8.relative)(rootDir, abs).split(import_node_path8.sep).join("/");
     for (const [name, hasFallback] of inFile) reads.push({ name, file, hasFallback });
   }
   return reads;
 }
 function envFileNames(rootDir) {
   const names = /* @__PURE__ */ new Set();
-  if (!(0, import_node_fs5.existsSync)(rootDir)) return names;
-  for (const entry of (0, import_node_fs5.readdirSync)(rootDir, { withFileTypes: true })) {
+  if (!(0, import_node_fs6.existsSync)(rootDir)) return names;
+  for (const entry of (0, import_node_fs6.readdirSync)(rootDir, { withFileTypes: true })) {
     if (!entry.isFile() || !(entry.name === ".env" || entry.name.startsWith(".env."))) continue;
     let text;
     try {
-      text = (0, import_node_fs5.readFileSync)((0, import_node_path7.join)(rootDir, entry.name), "utf8");
+      text = (0, import_node_fs6.readFileSync)((0, import_node_path8.join)(rootDir, entry.name), "utf8");
     } catch {
       continue;
     }
@@ -6031,7 +6276,9 @@ function feature(id) {
 var FRAMEWORK_TABLE = contract_default.frameworks;
 var SUPPORTED_FRAMEWORKS = FRAMEWORK_TABLE.map((f) => f.display_name).map((name, i, all) => i === all.length - 1 ? `or ${name}` : name).join(", ");
 var PLATFORM_CONTRACT = contract_default.contract_statement;
-var MAX_ZIP_UPLOAD_BYTES = contract_default.limits.max_zip_upload_bytes;
+function frameworkDisplayName(id) {
+  return FRAMEWORK_TABLE.find((f) => f.id === id)?.display_name ?? id;
+}
 var NEXT_CONFIG_BASENAMES = ["next.config.js", "next.config.ts", "next.config.mjs", "next.config.cjs"];
 var ROUTES_FEATURE = feature("app_route_handlers");
 var ROUTE_HANDLER_FILE = new RegExp(
@@ -6052,11 +6299,11 @@ var USE_SERVER = /^\s*(['"])use server\1\s*;?\s*$/m;
 var SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "dist", "build", "out"]);
 var SCAN_FILE_BUDGET2 = 5e3;
 function detectFramework(rootDir) {
-  const pkgPath = (0, import_node_path8.join)(rootDir, "package.json");
-  if (!(0, import_node_fs6.existsSync)(pkgPath)) return "vanilla";
+  const pkgPath = (0, import_node_path9.join)(rootDir, "package.json");
+  if (!(0, import_node_fs7.existsSync)(pkgPath)) return "vanilla";
   let pkg;
   try {
-    pkg = JSON.parse((0, import_node_fs6.readFileSync)(pkgPath, "utf8"));
+    pkg = JSON.parse((0, import_node_fs7.readFileSync)(pkgPath, "utf8"));
   } catch {
     return "unknown";
   }
@@ -6066,30 +6313,30 @@ function detectFramework(rootDir) {
 }
 function readDeps(rootDir) {
   try {
-    const pkg = JSON.parse((0, import_node_fs6.readFileSync)((0, import_node_path8.join)(rootDir, "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path9.join)(rootDir, "package.json"), "utf8"));
     return { ...pkg.dependencies, ...pkg.devDependencies };
   } catch {
     return {};
   }
 }
 function findFiles(rootDir, dir, pattern, out, cap = 20) {
-  if (out.length >= cap || !(0, import_node_fs6.existsSync)(dir)) return;
-  for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true })) {
+  if (out.length >= cap || !(0, import_node_fs7.existsSync)(dir)) return;
+  for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
     if (out.length >= cap) return;
-    const abs = (0, import_node_path8.join)(dir, entry.name);
+    const abs = (0, import_node_path9.join)(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS2.has(entry.name)) findFiles(rootDir, abs, pattern, out, cap);
     } else if (entry.isFile() && pattern.test(entry.name)) {
-      out.push((0, import_node_path8.relative)(rootDir, abs).split(import_node_path8.sep).join("/"));
+      out.push((0, import_node_path9.relative)(rootDir, abs).split(import_node_path9.sep).join("/"));
     }
   }
 }
 var sample = (list) => list.slice(0, 3).join(", ") + (list.length > 3 ? ", \u2026" : "");
 function collectSourceFiles(dir, out, budget) {
-  if (budget.left <= 0 || !(0, import_node_fs6.existsSync)(dir)) return;
-  for (const entry of (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true })) {
+  if (budget.left <= 0 || !(0, import_node_fs7.existsSync)(dir)) return;
+  for (const entry of (0, import_node_fs7.readdirSync)(dir, { withFileTypes: true })) {
     if (budget.left <= 0) return;
-    const abs = (0, import_node_path8.join)(dir, entry.name);
+    const abs = (0, import_node_path9.join)(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS2.has(entry.name)) collectSourceFiles(abs, out, budget);
     } else if (entry.isFile() && SOURCE_FILE.test(entry.name)) {
@@ -6101,10 +6348,10 @@ function collectSourceFiles(dir, out, budget) {
 function checkNextjs(rootDir) {
   const issues = [];
   const warnings = [];
-  const configName = NEXT_CONFIG_BASENAMES.find((name) => (0, import_node_fs6.existsSync)((0, import_node_path8.join)(rootDir, name)));
+  const configName = NEXT_CONFIG_BASENAMES.find((name) => (0, import_node_fs7.existsSync)((0, import_node_path9.join)(rootDir, name)));
   let hasStaticExport = true;
   if (configName) {
-    const config = (0, import_node_fs6.readFileSync)((0, import_node_path8.join)(rootDir, configName), "utf8");
+    const config = (0, import_node_fs7.readFileSync)((0, import_node_path9.join)(rootDir, configName), "utf8");
     hasStaticExport = STATIC_EXPORT.test(config);
     if (!hasStaticExport) {
       issues.push(
@@ -6118,15 +6365,15 @@ function checkNextjs(rootDir) {
   const hard = [];
   const pagesApi = [];
   for (const apiDir of PAGES_API_DIRS) {
-    findFiles(rootDir, (0, import_node_path8.join)(rootDir, apiDir), /\.(js|ts|jsx|tsx|mjs)$/, pagesApi);
+    findFiles(rootDir, (0, import_node_path9.join)(rootDir, apiDir), /\.(js|ts|jsx|tsx|mjs)$/, pagesApi);
   }
   if (pagesApi.length > 0) hard.push(`pages/api/* routes (${pagesApi.length} file(s))`);
   const middlewareFiles = [];
   for (const base of ["", "src"]) {
-    const dir = base ? (0, import_node_path8.join)(rootDir, base) : rootDir;
-    if (!(0, import_node_fs6.existsSync)(dir)) continue;
-    for (const entry of (0, import_node_fs6.readdirSync)(dir)) {
-      if (MIDDLEWARE_FILE.test(entry)) middlewareFiles.push((0, import_node_path8.join)(base, entry).split(import_node_path8.sep).join("/"));
+    const dir = base ? (0, import_node_path9.join)(rootDir, base) : rootDir;
+    if (!(0, import_node_fs7.existsSync)(dir)) continue;
+    for (const entry of (0, import_node_fs7.readdirSync)(dir)) {
+      if (MIDDLEWARE_FILE.test(entry)) middlewareFiles.push((0, import_node_path9.join)(base, entry).split(import_node_path9.sep).join("/"));
     }
   }
   hard.push(...middlewareFiles);
@@ -6138,11 +6385,11 @@ function checkNextjs(rootDir) {
     if (gssp.length >= 20 && useServer.length >= 20) break;
     let text;
     try {
-      text = (0, import_node_fs6.readFileSync)(abs, "utf8");
+      text = (0, import_node_fs7.readFileSync)(abs, "utf8");
     } catch {
       continue;
     }
-    const rel = (0, import_node_path8.relative)(rootDir, abs).split(import_node_path8.sep).join("/");
+    const rel = (0, import_node_path9.relative)(rootDir, abs).split(import_node_path9.sep).join("/");
     if (gssp.length < 20 && GET_SERVER_SIDE_PROPS.test(text)) gssp.push(rel);
     if (useServer.length < 20 && USE_SERVER.test(text)) useServer.push(rel);
   }
@@ -6150,7 +6397,7 @@ function checkNextjs(rootDir) {
   if (useServer.length > 0) hard.push(`'use server' actions (${sample(useServer)})`);
   const routeFiles = [];
   for (const appDir of APP_DIRS) {
-    findFiles(rootDir, (0, import_node_path8.join)(rootDir, appDir), ROUTE_HANDLER_FILE, routeFiles);
+    findFiles(rootDir, (0, import_node_path9.join)(rootDir, appDir), ROUTE_HANDLER_FILE, routeFiles);
   }
   if (routeFiles.length > 0) {
     const label = `${routeFiles.length} route handler(s) (${sample(routeFiles)})`;
@@ -6161,170 +6408,675 @@ function checkNextjs(rootDir) {
     } else {
       hard.push(label);
     }
-  }
-  const authDeps = Object.keys(readDeps(rootDir)).filter(isAuthDep);
-  if (authDeps.length > 0) {
-    const isAuthPath = (p) => p.toLowerCase().split("/").some((seg) => seg === "auth" || seg.includes("nextauth"));
-    const authRoutes = [...routeFiles, ...pagesApi].filter(isAuthPath);
-    if (authRoutes.length > 0) {
-      hard.push(`${authDeps.join(", ")} with its server-side auth route (${sample(authRoutes)})`);
-    } else {
-      warnings.push(
-        `${authDeps.join(", ")} is in dependencies but no auth route was found \u2014 server-side auth cannot run on the static platform. Remove the dependency, or keep auth in an external backend called from the client.`
-      );
+  }
+  const authDeps = Object.keys(readDeps(rootDir)).filter(isAuthDep);
+  if (authDeps.length > 0) {
+    const isAuthPath = (p) => p.toLowerCase().split("/").some((seg) => seg === "auth" || seg.includes("nextauth"));
+    const authRoutes = [...routeFiles, ...pagesApi].filter(isAuthPath);
+    if (authRoutes.length > 0) {
+      hard.push(`${authDeps.join(", ")} with its server-side auth route (${sample(authRoutes)})`);
+    } else {
+      warnings.push(
+        `${authDeps.join(", ")} is in dependencies but no auth route was found \u2014 server-side auth cannot run on the static platform. Remove the dependency, or keep auth in an external backend called from the client.`
+      );
+    }
+  }
+  if (hard.length > 0) {
+    issues.push(
+      `${PLATFORM_CONTRACT}
+  Your project needs a server runtime (found: ${hard.join("; ")}).
+  Options: (a) convert to a static export and move server logic to Managed Server Actions,
+  (b) keep the backend elsewhere and call it from the client, (c) don't push this project.`
+    );
+  }
+  return { issues, warnings };
+}
+function checkBuildEnv(rootDir) {
+  const verdict = judgeEnvReads(scanEnvReads(rootDir), {
+    defined: ALWAYS_DEFINED_NAMES,
+    backendUnknown: true,
+    localOnly: envFileNames(rootDir)
+  });
+  return [
+    ...verdict.errors.map((e) => `The cloud build will reject this project: ${e}`),
+    ...verdict.warnings
+  ];
+}
+function runPreflight(rootDir) {
+  const framework = detectFramework(rootDir);
+  const issues = [];
+  const warnings = [];
+  if (framework === "unknown") {
+    issues.push(
+      `No supported framework found in package.json. The cloud build supports: ${SUPPORTED_FRAMEWORKS}.`
+    );
+  }
+  if (framework === "nextjs") {
+    const next = checkNextjs(rootDir);
+    issues.push(...next.issues);
+    warnings.push(...next.warnings);
+  }
+  if (framework !== "vanilla") warnings.push(...checkBuildEnv(rootDir));
+  return { framework, issues, warnings };
+}
+
+// src/lib/pushAnalysis.ts
+var ANALYSIS_SCHEMA = "agentful.push-analysis";
+var ANALYSIS_SCHEMA_VERSION = 1;
+var DEFAULT_BUDGETS = {
+  exactFileBytes: 128 * 1024 * 1024,
+  exactTotalBytes: 256 * 1024 * 1024,
+  hashTotalBytes: 2 * 1024 * 1024 * 1024,
+  fileListCap: 5e3
+};
+var ZIP_ENTRY_HEADER_BYTES = 76;
+var ZIP_END_BYTES = 22;
+var DEFLATE_MAX_RATIO = 1032;
+var deflateUpperBound = (size) => size + 5 * (Math.floor(size / 16384) + 1);
+var LARGEST_FILES = 15;
+var TOP_LEVEL_GROUPS = 20;
+var DUPLICATE_GROUPS = 50;
+var HTML_CANDIDATES = 50;
+var EXCLUDED_ENTRIES = 200;
+var FINDING_PATHS = 20;
+var TITLE_SCAN_BYTES = 64 * 1024;
+var EMBEDDED_REPORT_MIN_CHARS = 64 * 1024;
+var EMBEDDED_SCAN_MIN_BYTES = EMBEDDED_REPORT_MIN_CHARS;
+var CLASS_EXTENSIONS = {
+  html: ["html", "htm", "xhtml"],
+  css: ["css", "scss", "sass", "less"],
+  script: ["js", "mjs", "cjs", "jsx", "ts", "tsx", "vue", "svelte", "astro"],
+  data: ["json", "geojson", "topojson", "xml", "csv", "tsv", "yaml", "yml", "toml", "txt", "md", "map", "webmanifest"],
+  image: ["png", "jpg", "jpeg", "gif", "webp", "avif", "svg", "ico", "bmp", "tif", "tiff", "heic"],
+  video: ["mp4", "m4v", "webm", "ogv", "mov", "avi", "mkv"],
+  audio: ["mp3", "wav", "ogg", "oga", "m4a", "flac", "aac", "opus"],
+  font: ["woff", "woff2", "ttf", "otf", "eot"],
+  document: ["pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "odt", "ods", "odp"],
+  archive: ["zip", "gz", "tgz", "tar", "bz2", "xz", "7z", "rar", "br", "zst"],
+  other: []
+};
+var CLASS_BY_EXTENSION = new Map(
+  Object.entries(CLASS_EXTENSIONS).flatMap(([cls, exts]) => exts.map((ext) => [ext, cls]))
+);
+var EMBEDDED_SCAN_CLASSES = /* @__PURE__ */ new Set(["html", "css", "script", "data"]);
+var baseName = (rel) => rel.slice(rel.lastIndexOf("/") + 1);
+function classOf(rel) {
+  const base = baseName(rel);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return "other";
+  return CLASS_BY_EXTENSION.get(base.slice(dot + 1).toLowerCase()) ?? "other";
+}
+var byPath = (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+var sha256Of = (data) => (0, import_node_crypto.createHash)("sha256").update(data).digest("hex");
+function sha256OfFile(abs) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  const fd2 = (0, import_node_fs8.openSync)(abs, "r");
+  try {
+    const chunk = Buffer.allocUnsafe(1024 * 1024);
+    for (; ; ) {
+      const read = (0, import_node_fs8.readSync)(fd2, chunk, 0, chunk.length, null);
+      if (read === 0) break;
+      hash.update(chunk.subarray(0, read));
+    }
+  } finally {
+    (0, import_node_fs8.closeSync)(fd2);
+  }
+  return hash.digest("hex");
+}
+var TITLE = /<title[^>]*>([\s\S]*?)<\/title>/i;
+function htmlTitle(content) {
+  const match = TITLE.exec(content.subarray(0, TITLE_SCAN_BYTES).toString("utf8"));
+  const title = match?.[1].replace(/\s+/g, " ").trim();
+  return title ? title.slice(0, 120) : null;
+}
+var DATA_URL = /data:([a-z0-9][a-z0-9.+-]*\/[a-z0-9][a-z0-9.+-]*)(?:;[a-z0-9-]+=[^;,\s"')]*)*;base64,([a-z0-9+/]+={0,2})/gi;
+function scanEmbeddedMedia(content) {
+  const text = content.toString("latin1");
+  if (!text.includes(";base64,")) return null;
+  let references = 0;
+  let base64Chars = 0;
+  const mimeTypes = {};
+  DATA_URL.lastIndex = 0;
+  for (let match = DATA_URL.exec(text); match; match = DATA_URL.exec(text)) {
+    references += 1;
+    base64Chars += match[2].length;
+    const mime = match[1].toLowerCase();
+    mimeTypes[mime] = (mimeTypes[mime] ?? 0) + 1;
+  }
+  if (references === 0) return null;
+  return {
+    references,
+    base64_chars: base64Chars,
+    decoded_bytes: Math.floor(base64Chars * 3 / 4),
+    mime_types: Object.fromEntries(Object.entries(mimeTypes).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+  };
+}
+function formatBytes(bytes2, rounding = "nearest") {
+  const units = ["B", "KiB", "MiB", "GiB"];
+  let value = bytes2;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  if (unit === 0 || Number.isInteger(value)) return `${value} ${units[unit]}`;
+  const tenths = value * 10;
+  const rounded = (rounding === "down" ? Math.floor(tenths) : Math.round(tenths)) / 10;
+  return `${rounded.toFixed(1)} ${units[unit]}`;
+}
+function sizeOverLimit(bytes2, limit) {
+  const size = formatBytes(bytes2);
+  const allowed = formatBytes(limit, "down");
+  const [value, unit] = size.split(" ");
+  const [limitValue, limitUnit] = allowed.split(" ");
+  if (unit !== limitUnit || Number(value) > Number(limitValue)) return [size, allowed];
+  return [`${bytes2.toLocaleString("en-US")} bytes`, `${limit.toLocaleString("en-US")} bytes`];
+}
+var plural = (count2, singular, pluralForm = `${singular}s`) => `${count2.toLocaleString("en-US")} ${count2 === 1 ? singular : pluralForm}`;
+var samplePaths = (paths) => paths.slice(0, 3).join(", ") + (paths.length > 3 ? `, and ${paths.length - 3} more` : "");
+function groupSizes(files, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const name = keyOf(file);
+    const group = groups.get(name) ?? { name, files: 0, bytes: 0, zip_bytes: 0 };
+    group.files += 1;
+    group.bytes += file.bytes;
+    group.zip_bytes += file.zip_bytes;
+    groups.set(name, group);
+  }
+  return [...groups.values()].sort((a, b) => b.bytes - a.bytes || (a.name < b.name ? -1 : 1));
+}
+var publicFile = ({ path, bytes: bytes2, zip_bytes, sha256, class: cls, zip_bytes_estimated }) => ({
+  path,
+  bytes: bytes2,
+  zip_bytes,
+  sha256,
+  class: cls,
+  ...zip_bytes_estimated ? { zip_bytes_estimated } : {}
+});
+function limits(maxZipBytes) {
+  return { max_zip_bytes: maxZipBytes, max_unpacked_bytes: MAX_UNPACKED_BYTES, max_files: MAX_UPLOAD_FILES };
+}
+function projectLink(projectDir) {
+  const config = readProjectConfig(projectDir);
+  return { linked: config !== null, project_id: config?.projectId ?? null };
+}
+function failedAnalysis(mode, projectDir, blocker) {
+  return {
+    schema: ANALYSIS_SCHEMA,
+    schema_version: ANALYSIS_SCHEMA_VERSION,
+    cli_version: VERSION,
+    mode,
+    root: null,
+    ok: false,
+    framework: null,
+    project: projectLink(projectDir),
+    limits: limits(maxZipBytesForUpload(mode)),
+    totals: {
+      files: 0,
+      bytes: 0,
+      zip_bytes: 0,
+      zip_bytes_exact: true,
+      zip_bytes_without_duplicates: 0,
+      stored_files: 0,
+      stored_bytes: 0
+    },
+    entry: { required: mode === "dist", expected: "index.html", found: false, path: null, candidates: [] },
+    flattened_prefix: null,
+    largest_files: [],
+    by_class: [],
+    by_top_level: [],
+    duplicates: [],
+    embedded_media: [],
+    excluded: { gitignore_applied: false, entries: [], omitted: 0 },
+    dropped_by_platform: [],
+    blockers: [{ overridable: false, ...blocker }],
+    warnings: [],
+    suggestions: [],
+    files: [],
+    files_omitted: 0,
+    fingerprint: `sha256:${sha256Of(Buffer.from(JSON.stringify({ v: ANALYSIS_SCHEMA_VERSION, mode, files: [] })))}`
+  };
+}
+function analyzePush(options) {
+  const { rootDir, mode } = options;
+  const projectDir = options.projectDir ?? rootDir;
+  const budgets = { ...DEFAULT_BUDGETS, ...options.budgets };
+  const scan = scanTree(rootDir, mode);
+  const collected = [...scan.files].sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+  const measured = [];
+  const unreadable = [];
+  const embeddedByHash = /* @__PURE__ */ new Map();
+  const embedded = [];
+  let exactUsed = 0;
+  let hashUsed = 0;
+  for (const file of collected) {
+    const cls = classOf(file.rel);
+    const headerBytes = ZIP_ENTRY_HEADER_BYTES + 2 * Buffer.byteLength(file.rel, "utf8");
+    try {
+      const size = (0, import_node_fs8.statSync)(file.abs).size;
+      if (size <= budgets.exactFileBytes && exactUsed + size <= budgets.exactTotalBytes) {
+        const content = (0, import_node_fs8.readFileSync)(file.abs);
+        exactUsed += content.length;
+        const sha2562 = sha256Of(content);
+        const zipBytes2 = headerBytes + deflateSync(content, { level: ZIP_LEVEL }).length;
+        if (EMBEDDED_SCAN_CLASSES.has(cls) && content.length >= EMBEDDED_SCAN_MIN_BYTES) {
+          if (!embeddedByHash.has(sha2562)) embeddedByHash.set(sha2562, scanEmbeddedMedia(content));
+          const found = embeddedByHash.get(sha2562);
+          if (found && found.base64_chars >= EMBEDDED_REPORT_MIN_CHARS) embedded.push({ path: file.rel, ...found });
+        }
+        measured.push({
+          path: file.rel,
+          bytes: content.length,
+          zip_bytes: zipBytes2,
+          zipLower: zipBytes2,
+          sha256: sha2562,
+          class: cls,
+          title: cls === "html" ? htmlTitle(content) : null
+        });
+        continue;
+      }
+      let sha256 = null;
+      if (hashUsed + size <= budgets.hashTotalBytes) {
+        sha256 = sha256OfFile(file.abs);
+        hashUsed += size;
+      }
+      measured.push({
+        path: file.rel,
+        bytes: size,
+        sha256,
+        class: cls,
+        title: null,
+        zip_bytes: headerBytes + deflateUpperBound(size),
+        zipLower: headerBytes + Math.ceil(size / DEFLATE_MAX_RATIO),
+        zip_bytes_estimated: true
+      });
+    } catch (err2) {
+      unreadable.push({ path: file.rel, error: err2.code ?? String(err2) });
+    }
+  }
+  const zipExact = measured.every((file) => !file.zip_bytes_estimated);
+  const sum = (pick) => measured.reduce((total, file) => total + pick(file), 0);
+  const totalBytes = sum((file) => file.bytes);
+  const zipBytes = measured.length > 0 ? sum((file) => file.zip_bytes) + ZIP_END_BYTES : 0;
+  const zipLower = measured.length > 0 ? sum((file) => file.zipLower) + ZIP_END_BYTES : 0;
+  const view = serverView(measured.map((file) => file.path));
+  const byPathMap = new Map(measured.map((file) => [file.path, file]));
+  const stored = measured.filter((file) => view.stored.has(file.path));
+  const storedBytes = stored.reduce((total, file) => total + file.bytes, 0);
+  const storedNames = new Map([...view.stored].map(([local, name]) => [name, local]));
+  const dropped = view.dropped.map((drop) => ({ path: drop.rel, bytes: byPathMap.get(drop.rel)?.bytes ?? 0, reason: drop.reason, matched: drop.matched })).sort(byPath);
+  const byHash = /* @__PURE__ */ new Map();
+  for (const file of measured) {
+    if (!file.sha256 || file.bytes === 0) continue;
+    const group = byHash.get(file.sha256);
+    if (group) group.push(file);
+    else byHash.set(file.sha256, [file]);
+  }
+  const firstOfContent = /* @__PURE__ */ new Map();
+  const duplicates = [];
+  for (const [sha256, group] of byHash) {
+    firstOfContent.set(sha256, group[0].path);
+    if (group.length < 2) continue;
+    duplicates.push({
+      sha256,
+      bytes: group[0].bytes,
+      paths: group.map((file) => file.path),
+      redundant_zip_bytes: group.slice(1).reduce((total, file) => total + file.zip_bytes, 0)
+    });
+  }
+  duplicates.sort((a, b) => b.redundant_zip_bytes - a.redundant_zip_bytes || (a.paths[0] < b.paths[0] ? -1 : 1));
+  const redundantZipBytes = duplicates.reduce((total, group) => total + group.redundant_zip_bytes, 0);
+  const preflight = mode === "source" ? runPreflight(rootDir) : null;
+  const framework = preflight?.framework ?? null;
+  const hasManifest = storedNames.has("package.json");
+  const entryRequired = mode === "dist" || !hasManifest;
+  const entryPath = storedNames.get("index.html") ?? null;
+  const entryMissing = entryRequired && entryPath === null && measured.length > 0;
+  const candidates = !entryMissing ? [] : stored.filter((file) => file.class === "html").sort((a, b) => a.path.split("/").length - b.path.split("/").length || byPath(a, b)).slice(0, HTML_CANDIDATES).map((file) => {
+    const first = file.sha256 ? firstOfContent.get(file.sha256) : void 0;
+    return {
+      path: file.path,
+      bytes: file.bytes,
+      title: file.title,
+      sha256: file.sha256,
+      same_content_as: first && first !== file.path ? first : null
+    };
+  });
+  const maxZipBytes = maxZipBytesForUpload(mode, mode === "source" ? readBackendDeclaration(rootDir) : null);
+  const zipLimit = formatBytes(maxZipBytes, "down");
+  const blockers = [];
+  const warnings = [];
+  const suggestions = [];
+  const dirLabel = mode === "dist" ? (0, import_node_path10.relative)(projectDir, rootDir).split(import_node_path10.sep).join("/") || "." : ".";
+  if (measured.length === 0 && unreadable.length === 0) {
+    blockers.push({
+      code: "empty_upload",
+      overridable: false,
+      message: "Nothing to push \u2014 no files found after applying ignore rules."
+    });
+  }
+  if (unreadable.length > 0) {
+    blockers.push({
+      code: "unreadable_file",
+      overridable: false,
+      message: `${plural(unreadable.length, "file")} cannot be read (${unreadable[0].error}): ${samplePaths(unreadable.map((f) => f.path))}.`,
+      paths: unreadable.map((f) => f.path).slice(0, FINDING_PATHS)
+    });
+  }
+  if (measured.length > MAX_UPLOAD_FILES) {
+    blockers.push({
+      code: "too_many_files",
+      overridable: false,
+      message: `${plural(measured.length, "file")} \u2014 the platform accepts at most ${MAX_UPLOAD_FILES.toLocaleString("en-US")} files per push.`
+    });
+  }
+  if (storedBytes > MAX_UNPACKED_BYTES) {
+    const [size, allowed] = sizeOverLimit(storedBytes, MAX_UNPACKED_BYTES);
+    blockers.push({
+      code: "unpacked_too_large",
+      overridable: false,
+      message: `The files add up to ${size} \u2014 the platform accepts at most ${allowed} of files per push.`
+    });
+  }
+  if (zipLower > maxZipBytes) {
+    const [size, allowed] = sizeOverLimit(zipExact ? zipBytes : zipLower, maxZipBytes);
+    blockers.push({
+      code: "zip_too_large",
+      overridable: false,
+      message: `The upload is ${zipExact ? "" : "at least "}${size} compressed \u2014 a push carries at most ${allowed} compressed.`
+    });
+  } else if (!zipExact && zipBytes > maxZipBytes) {
+    warnings.push({
+      code: "zip_size_unknown",
+      message: `The compressed size could not be determined: part of the tree is too large to compress during the analysis. It is between ${formatBytes(zipLower)} and ${formatBytes(zipBytes)}; a push carries at most ${zipLimit} compressed.`
+    });
+  }
+  if (entryMissing) {
+    blockers.push({
+      code: "entry_missing",
+      overridable: false,
+      message: mode === "dist" ? `No index.html at the top level of ${dirLabel === "." ? "the uploaded folder" : `${dirLabel}/`}. A prebuilt upload is served as it is, and index.html is its start page.` : "No index.html at the top level. Without a package.json this is a static site, and the platform serves index.html as its start page."
+    });
+  }
+  const backend = mode === "source" ? checkBackendDeclaration(rootDir) : null;
+  for (const message of preflight?.issues ?? []) blockers.push({ code: "preflight", overridable: true, message });
+  for (const message of backend?.issues ?? []) blockers.push({ code: "backend_declaration", overridable: true, message });
+  for (const message of preflight?.warnings ?? []) warnings.push({ code: "preflight", message });
+  for (const message of backend?.warnings ?? []) warnings.push({ code: "backend_declaration", message });
+  if (view.strippedPrefix) {
+    warnings.push({
+      code: "wrapper_directory_flattened",
+      message: `Everything sits in one folder, ${view.strippedPrefix} \u2014 the platform stores its content at the top level (${view.strippedPrefix}index.html becomes index.html).`
+    });
+  }
+  if (dropped.length > 0) {
+    const matched = [...new Set(dropped.map((drop) => drop.matched))];
+    warnings.push({
+      code: "dropped_by_platform",
+      message: `${plural(dropped.length, "file")} (${formatBytes(dropped.reduce((total, drop) => total + drop.bytes, 0))}) will be uploaded but not stored \u2014 the platform drops these paths by name (${samplePaths(matched)}): ${samplePaths(dropped.map((drop) => drop.path))}. If the site needs them, they have to live under another name.`,
+      paths: dropped.map((drop) => drop.path).slice(0, FINDING_PATHS)
+    });
+  }
+  if (mode === "source") {
+    const lostDirs = scan.excluded.filter((entry) => entry.reason === "always_excluded_dir" && ["dist", "build", "out"].includes(baseName(entry.rel).toLowerCase())).filter((entry) => framework === "vanilla" || /^(public|static)\//.test(entry.rel)).map((entry) => `${entry.rel}/`).sort();
+    if (lostDirs.length > 0) {
+      warnings.push({
+        code: "excluded_static_directory",
+        message: `${samplePaths(lostDirs)} ${lostDirs.length === 1 ? "is" : "are"} never uploaded: folders named dist, build or out are treated as build output. ${framework === "vanilla" ? "This site has no build step" : "Files under public/ and static/ are served as they are"}, so nothing recreates them \u2014 if the site needs these files, move them to a folder with another name.`,
+        paths: lostDirs.slice(0, FINDING_PATHS)
+      });
+    }
+  }
+  const filesOmitted = Math.max(0, measured.length - budgets.fileListCap);
+  if (filesOmitted > 0) {
+    warnings.push({
+      code: "file_list_truncated",
+      message: `The file list of this report holds the first ${budgets.fileListCap.toLocaleString("en-US")} of ${plural(measured.length, "file")}; the totals cover all of them.`
+    });
+  }
+  const tooLarge = blockers.some((b) => b.code === "zip_too_large" || b.code === "unpacked_too_large");
+  if (entryMissing) {
+    if (candidates.length > 0) {
+      suggestions.push({
+        code: "name_start_page",
+        message: "Rename or copy the page that should open first to index.html at the top level, check that its relative links still resolve, then push again.",
+        paths: candidates.map((candidate) => candidate.path).slice(0, FINDING_PATHS)
+      });
+    }
+    const siteDirs = /* @__PURE__ */ new Set();
+    for (const file of stored) {
+      if (baseName(file.path) === "index.html" && file.path.includes("/")) siteDirs.add(file.path.slice(0, file.path.lastIndexOf("/")));
+    }
+    if (mode === "source") {
+      for (const dir of ["dist", "build", "out", ".output/public"]) {
+        if ((0, import_node_fs8.existsSync)((0, import_node_path10.join)(rootDir, dir, "index.html"))) siteDirs.add(dir);
+      }
+    }
+    for (const dir of [...siteDirs].sort().slice(0, 5)) {
+      const target = mode === "dist" ? `${dirLabel === "." ? "" : `${dirLabel}/`}${dir}` : dir;
+      suggestions.push({
+        code: "push_site_directory",
+        message: `${target}/ has an index.html of its own. If that folder is the finished site, upload it on its own \u2014 only the files inside it are served.`,
+        command: `agentful push --prebuilt --dir ${target}`
+      });
     }
   }
-  if (hard.length > 0) {
-    issues.push(
-      `${PLATFORM_CONTRACT}
-  Your project needs a server runtime (found: ${hard.join("; ")}).
-  Options: (a) convert to a static export and move server logic to Managed Server Actions,
-  (b) keep the backend elsewhere and call it from the client, (c) don't push this project.`
-    );
+  if (tooLarge) {
+    const oversized = measured.filter((file) => file.zipLower > maxZipBytes).sort((a, b) => b.bytes - a.bytes || byPath(a, b));
+    if (oversized.length > 0) {
+      suggestions.push({
+        code: "oversized_files",
+        message: `${samplePaths(oversized.map((file) => `${file.path} (${formatBytes(file.zipLower)} compressed)`))} ${oversized.length === 1 ? "is" : "are each"} larger than a whole push can carry. The upload cannot fit while ${oversized.length === 1 ? "it is" : "they are"} part of it.`,
+        paths: oversized.map((file) => file.path).slice(0, FINDING_PATHS)
+      });
+    }
+    if (duplicates.length > 0 && redundantZipBytes >= zipBytes / 20) {
+      const copies = duplicates.reduce((total, group) => total + group.paths.length - 1, 0);
+      const remaining = zipBytes - redundantZipBytes;
+      suggestions.push({
+        code: "remove_identical_copies",
+        message: `${plural(copies, "file is an identical copy", "files are identical copies")} of another file and ${copies === 1 ? "adds" : "add"} ${formatBytes(redundantZipBytes)} to the compressed upload. If nothing links to the extra names, one copy each brings it to ${formatBytes(remaining)}${remaining > maxZipBytes ? ` \u2014 still above the ${zipLimit} limit` : ""}.`,
+        paths: duplicates.flatMap((group) => group.paths.slice(1)).slice(0, FINDING_PATHS)
+      });
+    }
+    suggestions.push(mode === "source" ? {
+      code: "exclude_with_gitignore",
+      message: "Files and folders listed in .gitignore are not uploaded. Leave out what the site does not serve \u2014 originals, working files, exports."
+    } : {
+      code: "narrow_prebuilt_directory",
+      message: "A prebuilt upload takes every file in the folder. Put the finished site into a folder of its own and pass it with --dir."
+    });
+    suggestions.push({
+      code: "upload_limit",
+      message: `A push carries at most ${zipLimit} compressed and ${formatBytes(MAX_UNPACKED_BYTES)} of files. A site that stays above that cannot be pushed yet.`
+    });
   }
-  return { issues, warnings };
-}
-function checkBuildEnv(rootDir) {
-  const verdict = judgeEnvReads(scanEnvReads(rootDir), {
-    defined: ALWAYS_DEFINED_NAMES,
-    backendUnknown: true,
-    localOnly: envFileNames(rootDir)
+  const excludedEntries = [...scan.excluded].sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0).slice(0, EXCLUDED_ENTRIES).map((entry) => {
+    let bytes2;
+    if (entry.kind === "file") {
+      try {
+        bytes2 = (0, import_node_fs8.lstatSync)((0, import_node_path10.join)(rootDir, entry.rel)).size;
+      } catch {
+      }
+    }
+    return { path: entry.rel, kind: entry.kind, reason: entry.reason, ...bytes2 === void 0 ? {} : { bytes: bytes2 } };
   });
-  return [
-    ...verdict.errors.map((e) => `The cloud build will reject this project: ${e}`),
-    ...verdict.warnings
-  ];
+  const fingerprint = sha256Of(Buffer.from(JSON.stringify({
+    v: ANALYSIS_SCHEMA_VERSION,
+    mode,
+    files: measured.map((file) => [file.path, file.bytes, file.sha256])
+  })));
+  return {
+    schema: ANALYSIS_SCHEMA,
+    schema_version: ANALYSIS_SCHEMA_VERSION,
+    cli_version: VERSION,
+    mode,
+    root: rootDir,
+    ok: blockers.length === 0,
+    framework,
+    project: projectLink(projectDir),
+    limits: limits(maxZipBytes),
+    totals: {
+      files: measured.length,
+      bytes: totalBytes,
+      zip_bytes: zipBytes,
+      zip_bytes_exact: zipExact,
+      zip_bytes_without_duplicates: zipBytes - redundantZipBytes,
+      stored_files: stored.length,
+      stored_bytes: storedBytes
+    },
+    entry: { required: entryRequired, expected: "index.html", found: entryPath !== null, path: entryPath, candidates },
+    flattened_prefix: view.strippedPrefix || null,
+    largest_files: [...measured].sort((a, b) => b.bytes - a.bytes || byPath(a, b)).slice(0, LARGEST_FILES).map(publicFile),
+    by_class: groupSizes(measured, (file) => file.class),
+    by_top_level: groupSizes(measured, (file) => file.path.includes("/") ? file.path.slice(0, file.path.indexOf("/")) : ".").slice(0, TOP_LEVEL_GROUPS),
+    duplicates: duplicates.slice(0, DUPLICATE_GROUPS),
+    embedded_media: embedded.sort((a, b) => b.base64_chars - a.base64_chars || byPath(a, b)),
+    excluded: {
+      gitignore_applied: scan.gitignoreApplied,
+      entries: excludedEntries,
+      omitted: Math.max(0, scan.excluded.length - EXCLUDED_ENTRIES)
+    },
+    dropped_by_platform: dropped,
+    blockers,
+    warnings,
+    suggestions,
+    files: measured.slice(0, budgets.fileListCap).map(publicFile),
+    files_omitted: filesOmitted,
+    fingerprint: `sha256:${fingerprint}`
+  };
 }
-function runPreflight(rootDir) {
-  const framework = detectFramework(rootDir);
-  const issues = [];
-  const warnings = [];
-  if (framework === "unknown") {
-    issues.push(
-      `No supported framework found in package.json. The cloud build supports: ${SUPPORTED_FRAMEWORKS}.`
-    );
-  }
-  if (framework === "nextjs") {
-    const next = checkNextjs(rootDir);
-    issues.push(...next.issues);
-    warnings.push(...next.warnings);
-  }
-  if (framework !== "vanilla") warnings.push(...checkBuildEnv(rootDir));
-  return { framework, issues, warnings };
+function wouldUpload(analysis, force = false) {
+  return analysis.blockers.every((blocker) => blocker.overridable && force);
 }
 
-// src/lib/backendDecl.ts
-var import_node_fs7 = require("fs");
-var import_node_path9 = require("path");
-function readBackendDeclaration(dir = process.cwd()) {
-  const path = (0, import_node_path9.join)(dir, ".agentful", "backend.json");
-  if (!(0, import_node_fs7.existsSync)(path)) return null;
-  try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(path, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-    const collections = Array.isArray(parsed.collections) ? parsed.collections.filter((c) => c && typeof c === "object" && !Array.isArray(c)) : [];
-    const secrets = Array.isArray(parsed.secrets) ? parsed.secrets.filter((s) => s && typeof s === "object" && !Array.isArray(s)) : [];
-    const auth = parsed.auth && typeof parsed.auth === "object" && !Array.isArray(parsed.auth) ? parsed.auth : void 0;
-    const decl = {
-      ...parsed,
-      schema_version: Number(parsed.schema_version) || 1,
-      managed_db: Boolean(parsed.managed_db),
-      actions: Array.isArray(parsed.actions) ? parsed.actions.filter((a) => typeof a === "string") : [],
-      contract_doc: typeof parsed.contract_doc === "string" ? parsed.contract_doc : void 0,
-      collections,
-      secrets,
-      auth
-    };
-    const loginMethods = authMethodsOf(decl);
-    if (!decl.managed_db && decl.actions.length === 0 && collections.length === 0 && secrets.length === 0 && loginMethods.length === 0) {
-      return null;
+// src/lib/pushReport.ts
+init_branding();
+var EXCLUDE_REASON = {
+  always_excluded_dir: "never uploaded",
+  gitignore: ".gitignore",
+  env_file: "env file, never uploaded",
+  os_junk: "system file",
+  symlink: "symbolic link",
+  not_a_regular_file: "not a regular file"
+};
+var SHOWN_FILES = 8;
+var SHOWN_GROUPS = 6;
+var SHOWN_EXCLUDED = 12;
+var count = (n, singular, pluralForm = `${singular}s`) => `${n.toLocaleString("en-US")} ${n === 1 ? singular : pluralForm}`;
+var more = (total, shown, what) => total > shown ? [paint.dim(`    \u2026 and ${count(total - shown, `more ${what}`, `more ${what}s`)}`)] : [];
+var bullet = (message) => message.split("\n").map((line, index) => index === 0 ? `  \u2022 ${line}` : `    ${line.trimStart()}`);
+var sizeColumn = (bytes2) => formatBytes(bytes2).padStart(9);
+var fileLine = (file) => `  ${sizeColumn(file.bytes)}  ${file.path}` + paint.dim(`  (${file.zip_bytes_estimated ? "up to " : ""}${formatBytes(file.zip_bytes)} compressed)`);
+function headline(analysis) {
+  if (analysis.mode === "dist") return "prebuilt upload, served as it is (no cloud build)";
+  if (analysis.framework === "vanilla") return "source push, static site without a build step";
+  if (analysis.framework === "unknown" || analysis.framework === null) return "source push";
+  return `source push, built in the cloud as ${frameworkDisplayName(analysis.framework)}`;
+}
+function renderAnalysis(analysis, options = {}) {
+  const { totals, limits: limits2 } = analysis;
+  const lines = [];
+  const section = (title) => {
+    lines.push("", paint.bold(title));
+  };
+  lines.push(paint.bold("Upload analysis") + paint.dim(`: ${headline(analysis)}`));
+  if (analysis.root) lines.push(paint.dim(analysis.root));
+  if (totals.files > 0) {
+    lines.push(
+      `${count(totals.files, "file")} \xB7 ${formatBytes(totals.bytes)} \xB7 ${totals.zip_bytes_exact ? "" : "up to "}${formatBytes(totals.zip_bytes)} compressed`
+    );
+  }
+  lines.push(paint.dim(
+    `Limits per push: ${formatBytes(limits2.max_zip_bytes, "down")} compressed \xB7 ${formatBytes(limits2.max_unpacked_bytes)} of files \xB7 ${limits2.max_files.toLocaleString("en-US")} files`
+  ));
+  if (analysis.blockers.length > 0) {
+    lines.push("", `${sym.fail} ${paint.bold("This push cannot go through as it is:")}`);
+    for (const blocker of analysis.blockers) {
+      lines.push(...bullet(blocker.message + (blocker.overridable ? paint.dim("  [--force uploads anyway]") : "")));
     }
-    return decl;
-  } catch {
-    return null;
   }
-}
-function authMethodsOf(decl) {
-  const raw = decl?.auth?.end_user_login;
-  return Array.isArray(raw) ? raw.filter((m) => typeof m === "string") : [];
-}
-function describeBackendDeclaration(decl) {
-  const parts = [];
-  const collections = decl.collections ?? [];
-  if (decl.managed_db || collections.length > 0) {
-    parts.push(collections.length > 0 ? `managed DB with ${collections.length} collection(s)` : "managed DB");
+  if (analysis.warnings.length > 0) {
+    section("Warnings");
+    for (const warning of analysis.warnings) lines.push(...bullet(warning.message));
   }
-  if (decl.actions && decl.actions.length > 0) parts.push(`${decl.actions.length} server action(s)`);
-  if (decl.secrets && decl.secrets.length > 0) parts.push(`${decl.secrets.length} secret(s)`);
-  const login = authMethodsOf(decl);
-  if (login.length > 0) parts.push(`login: ${login.join(" + ")}`);
-  const base = parts.join(" + ") || "managed backend";
-  return decl.contract_doc ? `${base} (contract: ${decl.contract_doc})` : base;
-}
-function backendTabUrl(userId, projectId) {
-  return `${APP_URL}/workspace/${userId}/${projectId}?view=backend`;
-}
-var ACTIONS_DIR = (0, import_node_path9.join)(".server", "actions");
-var ACTION_NAME = /^[a-z][a-z0-9_-]{0,62}$/;
-function checkBackendDeclaration(rootDir = process.cwd()) {
-  const issues = [];
-  const warnings = [];
-  const actionsDir = (0, import_node_path9.join)(rootDir, ACTIONS_DIR);
-  const presentFiles = /* @__PURE__ */ new Set();
-  if ((0, import_node_fs7.existsSync)(actionsDir)) {
-    for (const entry of (0, import_node_fs7.readdirSync)(actionsDir)) {
-      const abs = (0, import_node_path9.join)(actionsDir, entry);
-      let isDir = false;
-      try {
-        isDir = (0, import_node_fs7.statSync)(abs).isDirectory();
-      } catch {
-        continue;
+  if (analysis.entry.required && totals.files > 0) {
+    section("Start page");
+    if (analysis.entry.found) {
+      lines.push(`  ${analysis.entry.path}`);
+    } else {
+      lines.push("  missing \u2014 the platform serves index.html from the top level");
+      if (analysis.entry.candidates.length > 0) {
+        lines.push("  HTML files found:");
+        for (const candidate of analysis.entry.candidates.slice(0, SHOWN_FILES)) {
+          lines.push(
+            `  ${sizeColumn(candidate.bytes)}  ${candidate.path}` + (candidate.title ? paint.dim(`  "${candidate.title}"`) : "") + (candidate.same_content_as ? paint.dim(`  (same content as ${candidate.same_content_as})`) : "")
+          );
+        }
+        lines.push(...more(analysis.entry.candidates.length, SHOWN_FILES, "HTML file"));
+      } else {
+        lines.push("  no HTML file in the upload");
       }
-      if (isDir) {
-        issues.push(
-          `.server/actions/${entry}/ is a directory \u2014 action files must live directly under .server/actions/ (the platform rejects subdirectories).`
+    }
+  }
+  const sizeMatters = analysis.blockers.some((b) => ["zip_too_large", "unpacked_too_large", "too_many_files"].includes(b.code)) || analysis.warnings.some((w) => w.code === "zip_size_unknown");
+  if (totals.files > 0 && (sizeMatters || options.dryRun)) {
+    section("Largest files");
+    for (const file of analysis.largest_files.slice(0, SHOWN_FILES)) lines.push(fileLine(file));
+    lines.push(...more(totals.files, Math.min(SHOWN_FILES, analysis.largest_files.length), "file"));
+    section("By type");
+    for (const group of analysis.by_class.slice(0, SHOWN_GROUPS)) {
+      lines.push(
+        `  ${sizeColumn(group.bytes)}  ${group.name.padEnd(9)} ${count(group.files, "file")}` + paint.dim(`  (${formatBytes(group.zip_bytes)} compressed)`)
+      );
+    }
+    if (analysis.duplicates.length > 0) {
+      section("Identical content");
+      for (const group of analysis.duplicates.slice(0, SHOWN_GROUPS)) {
+        lines.push(
+          `  ${group.paths.length} \xD7 ${formatBytes(group.bytes)}  ${group.paths.join(" = ")}` + paint.dim(`  (the extra ${group.paths.length === 2 ? "copy is" : "copies are"} ${formatBytes(group.redundant_zip_bytes)} of the compressed upload)`)
         );
-        continue;
       }
-      presentFiles.add(entry);
-      const name = entry.endsWith(".js") ? entry.slice(0, -3) : null;
-      if (name === null || !ACTION_NAME.test(name)) {
-        issues.push(
-          `.server/actions/${entry}: invalid action filename \u2014 must match [a-z][a-z0-9_-]{0,62}.js (names starting with _ are reserved). The platform rejects the whole push otherwise.`
+      lines.push(...more(analysis.duplicates.length, SHOWN_GROUPS, "group"));
+    }
+    if (analysis.embedded_media.length > 0) {
+      section("Media embedded in text files");
+      const sizeOf = new Map(analysis.files.map((file) => [file.path, file.bytes]));
+      for (const item of analysis.embedded_media.slice(0, SHOWN_GROUPS)) {
+        const fileBytes = sizeOf.get(item.path);
+        lines.push(
+          `  ${item.path}: ${count(item.references, "embedded file")} (data: URLs), ${formatBytes(item.base64_chars)}` + (fileBytes ? ` of its ${formatBytes(fileBytes)}` : "")
         );
       }
+      lines.push(...more(analysis.embedded_media.length, SHOWN_GROUPS, "file"));
     }
   }
-  const decl = readBackendDeclaration(rootDir);
-  const declared = decl?.actions ?? [];
-  for (const name of declared) {
-    if (!ACTION_NAME.test(name)) {
-      issues.push(
-        `.agentful/backend.json declares action "${name}" \u2014 names must match [a-z][a-z0-9_-]{0,62} (the filename without .js).`
-      );
-      continue;
-    }
-    if (!presentFiles.has(`${name}.js`)) {
-      issues.push(
-        `.agentful/backend.json declares action "${name}" but .server/actions/${name}.js does not exist \u2014 create the file or remove the declaration entry.`
+  if (options.dryRun && analysis.excluded.entries.length > 0) {
+    section("Not uploaded");
+    for (const entry of analysis.excluded.entries.slice(0, SHOWN_EXCLUDED)) {
+      lines.push(
+        `  ${entry.path}${entry.kind === "dir" ? "/" : ""}` + paint.dim(`  (${EXCLUDE_REASON[entry.reason] ?? entry.reason}${entry.bytes === void 0 ? "" : `, ${formatBytes(entry.bytes)}`})`)
       );
     }
+    lines.push(...more(analysis.excluded.entries.length + analysis.excluded.omitted, SHOWN_EXCLUDED, "entry"));
   }
-  const declaredSet = new Set(declared);
-  for (const file of presentFiles) {
-    const name = file.endsWith(".js") ? file.slice(0, -3) : file;
-    if (ACTION_NAME.test(name) && !declaredSet.has(name)) {
-      warnings.push(
-        `.server/actions/${file} is not declared in .agentful/backend.json \u2014 it will deploy, but \`agentful backend\` and the Backend tab won't know about it. Add "${name}" to the actions list.`
-      );
+  if (analysis.suggestions.length > 0) {
+    section("What you can do");
+    for (const suggestion of analysis.suggestions) {
+      lines.push(...bullet(suggestion.message));
+      if (suggestion.command) lines.push(`    ${paint.accent(suggestion.command)}`);
     }
   }
-  if (decl && decl.schema_version < 2 && ((decl.collections?.length ?? 0) > 0 || (decl.secrets?.length ?? 0) > 0 || authMethodsOf(decl).length > 0)) {
-    issues.push(
-      '.agentful/backend.json declares collections/secrets/auth but has "schema_version": 1 \u2014 set it to 2 (schema_version 1 declares actions only).'
-    );
+  if (options.dryRun) {
+    lines.push("");
+    if (wouldUpload(analysis, options.force)) {
+      lines.push(`${sym.ok} Nothing blocks this push.` + paint.dim(" Dry run: nothing was uploaded, no project was created."));
+    } else {
+      lines.push(`${sym.fail} ${paint.error("agentful push would stop here.")}` + paint.dim(" Dry run: nothing was uploaded, no project was created."));
+    }
   }
-  return { issues, warnings };
+  return lines;
 }
 
 // src/lib/backendSync.ts
@@ -6493,8 +7245,8 @@ function describeBackendState(state) {
 }
 
 // src/lib/backendConsent.ts
-var import_node_fs8 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path11 = require("path");
 var import_promises2 = require("readline/promises");
 function declaresManagedDatabase(decl) {
   if (!decl) return false;
@@ -6520,10 +7272,10 @@ function consentQuestion(decl) {
     'It is the same switch as the Backend tab; this push then applies the declaration. A "no" is remembered for this project (`agentful push --yes` or `agentful backend` enables it later).'
   ].join("\n");
 }
-var consentFile = () => (0, import_node_path10.join)(configDir(), "backend-consent.json");
+var consentFile = () => (0, import_node_path11.join)(configDir(), "backend-consent.json");
 function readConsentFile() {
   try {
-    const raw = JSON.parse((0, import_node_fs8.readFileSync)(consentFile(), "utf8"));
+    const raw = JSON.parse((0, import_node_fs9.readFileSync)(consentFile(), "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   } catch {
     return {};
@@ -6535,15 +7287,15 @@ function hasRememberedDecline(projectId) {
 function rememberDecline(projectId) {
   const all = readConsentFile();
   all[projectId] = { declined_at: (/* @__PURE__ */ new Date()).toISOString() };
-  (0, import_node_fs8.mkdirSync)(configDir(), { recursive: true });
-  (0, import_node_fs8.writeFileSync)(consentFile(), JSON.stringify(all, null, 2) + "\n", "utf8");
+  (0, import_node_fs9.mkdirSync)(configDir(), { recursive: true });
+  (0, import_node_fs9.writeFileSync)(consentFile(), JSON.stringify(all, null, 2) + "\n", "utf8");
 }
 function forgetDecline(projectId) {
-  if (!(0, import_node_fs8.existsSync)(consentFile())) return;
+  if (!(0, import_node_fs9.existsSync)(consentFile())) return;
   const all = readConsentFile();
   if (!(projectId in all)) return;
   delete all[projectId];
-  (0, import_node_fs8.writeFileSync)(consentFile(), JSON.stringify(all, null, 2) + "\n", "utf8");
+  (0, import_node_fs9.writeFileSync)(consentFile(), JSON.stringify(all, null, 2) + "\n", "utf8");
 }
 async function enableManagedDatabase(auth, userId, projectId) {
   try {
@@ -6659,34 +7411,61 @@ function brandPreviewUrl(previewUrl, projectId) {
   if (!previewUrl) return fallback;
   try {
     const url = new URL(previewUrl);
-    if (url.hostname.endsWith(".mainmvp.com")) {
-      url.hostname = url.hostname.replace(/\.mainmvp\.com$/, `.${PREVIEW_DOMAIN}`);
-    }
+    url.hostname = url.hostname.replace(/\.(?:mainmvp\.com|agentful\.dev)$/, `.${PREVIEW_DOMAIN}`);
     return url.toString();
   } catch {
     return fallback;
   }
 }
 async function pushCommand(opts) {
-  console.log(banner());
+  if (opts.json && !opts.dryRun) {
+    throw new ApiError(
+      0,
+      "invalid_options",
+      "--json belongs to --dry-run: `agentful push --dry-run --json` prints the upload analysis and uploads nothing."
+    );
+  }
+  if (!opts.json) console.log(banner());
   const mode = opts.prebuilt ? "dist" : "source";
-  const rootDir = opts.prebuilt ? detectDistDir(process.cwd(), opts.dir) : process.cwd();
-  if (mode === "source") {
-    const pre = runPreflight(process.cwd());
-    const backendCheck = checkBackendDeclaration(process.cwd());
-    const issues = [...pre.issues, ...backendCheck.issues];
-    for (const warning of [...pre.warnings, ...backendCheck.warnings]) ui.warn(warning);
-    if (issues.length > 0) {
-      if (opts.force) {
-        ui.warn(`Preflight found ${issues.length} blocking issue(s) \u2014 continuing because of --force:`);
-        for (const issue of issues) ui.info(issue);
-      } else {
-        throw new ApiError(
-          0,
-          "preflight_failed",
-          "This project cannot run on the platform as pushed:\n" + issues.map((issue) => `\u2022 ${issue}`).join("\n") + "\nPush with --force to attempt the cloud build anyway."
-        );
-      }
+  const cwd = process.cwd();
+  let rootDir = cwd;
+  let analysis;
+  try {
+    if (opts.prebuilt) rootDir = detectDistDir(cwd, opts.dir);
+    analysis = analyzePush({ rootDir, mode, projectDir: cwd });
+  } catch (err2) {
+    if (!opts.dryRun || !(err2 instanceof ApiError)) throw err2;
+    analysis = failedAnalysis(mode, cwd, { code: err2.code, message: err2.message });
+  }
+  if (opts.dryRun) {
+    if (opts.json) process.stdout.write(`${JSON.stringify(analysis, null, 2)}
+`);
+    else for (const line of renderAnalysis(analysis, { force: opts.force, dryRun: true })) console.log(line);
+    if (!wouldUpload(analysis, opts.force)) process.exitCode = 1;
+    return;
+  }
+  const overridable = analysis.blockers.filter((blocker) => blocker.overridable);
+  if (analysis.blockers.length > overridable.length) {
+    for (const line of renderAnalysis(analysis, { force: opts.force })) console.log(line);
+    console.log("");
+    throw new ApiError(
+      0,
+      "push_blocked",
+      "Push stopped before sign-in: nothing was uploaded and no project was created. `agentful push --dry-run` shows this analysis again."
+    );
+  }
+  for (const warning of analysis.warnings) ui.warn(warning.message);
+  if (overridable.length > 0) {
+    const issues = overridable.map((blocker) => blocker.message);
+    if (opts.force) {
+      ui.warn(`Preflight found ${issues.length} blocking issue(s) \u2014 continuing because of --force:`);
+      for (const issue of issues) ui.info(issue);
+    } else {
+      throw new ApiError(
+        0,
+        "preflight_failed",
+        "This project cannot run on the platform as pushed:\n" + issues.map((issue) => `\u2022 ${issue}`).join("\n") + "\nPush with --force to attempt the cloud build anyway."
+      );
     }
   }
   const auth = await ensureAuth();
@@ -6705,17 +7484,10 @@ async function pushCommand(opts) {
     );
   }
   ui.step(mode === "source" ? "Packing source tree\u2026" : `Packing built output (${rootDir})\u2026`);
-  const files = collectFiles(rootDir, mode);
-  const zip = zipToBase64(files);
-  ui.info(`${zip.count} files, ${(zip.bytes / 1024).toFixed(0)} KB compressed`);
-  if (zip.bytes > MAX_ZIP_UPLOAD_BYTES) {
-    throw new ApiError(
-      0,
-      "zip_too_large",
-      `Packed ${(zip.bytes / 1024 / 1024).toFixed(1)} MB compressed \u2014 the platform caps uploads at ${Math.floor(MAX_ZIP_UPLOAD_BYTES / (1024 * 1024))} MB. Remove large media or generated files from the source tree (node_modules, dist and .git are excluded automatically); large assets belong in the platform asset flow.`
-    );
-  }
   const declaration = mode === "source" ? readBackendDeclaration() : null;
+  const files = collectFiles(rootDir, mode);
+  const zip = zipToBase64(files, maxZipBytesForUpload(mode, declaration));
+  ui.info(`${zip.count} files, ${(zip.bytes / 1024).toFixed(0)} KiB compressed`);
   if (declaration) {
     const consent = await ensureDatabaseConsent({
       auth,
@@ -6736,12 +7508,7 @@ async function pushCommand(opts) {
     `${API_URL}/api/workspaces/${userId}/${projectId}/source-zip`,
     {
       token: auth.pb_token,
-      body: {
-        zip_base64: zip.base64,
-        mode,
-        clean: true,
-        ...declaration ? { backend_declaration: declaration } : {}
-      },
+      body: uploadRequestBody(zip.base64, mode, declaration),
       timeoutMs: 12e4,
       retry: platformRetry
     }
@@ -6921,15 +7688,15 @@ async function openCommand() {
 // src/commands/tui.ts
 var import_node_child_process6 = require("child_process");
 var import_promises4 = require("readline/promises");
-var import_node_path21 = require("path");
+var import_node_path22 = require("path");
 
 // src/lib/binWrapper.ts
-var import_node_fs9 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path12 = require("path");
 var import_node_os3 = require("os");
 function ensureCliOnPath() {
-  const binDir = (0, import_node_path11.join)((0, import_node_os3.homedir)(), ".local", "share", "agentful", "bin");
-  (0, import_node_fs9.mkdirSync)(binDir, { recursive: true });
+  const binDir = (0, import_node_path12.join)((0, import_node_os3.homedir)(), ".local", "share", "agentful", "bin");
+  (0, import_node_fs10.mkdirSync)(binDir, { recursive: true });
   const entry = process.argv[1];
   if (!entry) return binDir;
   const restore = (name) => {
@@ -6938,8 +7705,8 @@ function ensureCliOnPath() {
 ` : `export ${name}=${JSON.stringify(original)}
 `;
   };
-  const wrapper = (0, import_node_path11.join)(binDir, "agentful");
-  (0, import_node_fs9.writeFileSync)(
+  const wrapper = (0, import_node_path12.join)(binDir, "agentful");
+  (0, import_node_fs10.writeFileSync)(
     wrapper,
     `#!/bin/sh
 # Generated by the Agentful CLI so the coding agent can run \`agentful \u2026\`.
@@ -6949,7 +7716,7 @@ function ensureCliOnPath() {
     "utf8"
   );
   try {
-    (0, import_node_fs9.chmodSync)(wrapper, 493);
+    (0, import_node_fs10.chmodSync)(wrapper, 493);
   } catch {
   }
   return binDir;
@@ -6959,9 +7726,9 @@ function ensureCliOnPath() {
 init_branding();
 
 // src/lib/engine.ts
-var import_node_fs10 = require("fs");
-var import_node_crypto = require("crypto");
-var import_node_path12 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_crypto2 = require("crypto");
+var import_node_path13 = require("path");
 var import_node_os4 = require("os");
 var import_node_child_process3 = require("child_process");
 var import_node_stream = require("stream");
@@ -7006,8 +7773,8 @@ function platformKey() {
   );
 }
 function cacheDir(version) {
-  const base = process.env.XDG_CACHE_HOME || (0, import_node_path12.join)((0, import_node_os4.homedir)(), ".cache");
-  return (0, import_node_path12.join)(base, "agentful", "engine", version);
+  const base = process.env.XDG_CACHE_HOME || (0, import_node_path13.join)((0, import_node_os4.homedir)(), ".cache");
+  return (0, import_node_path13.join)(base, "agentful", "engine", version);
 }
 async function fetchManifest() {
   try {
@@ -7017,8 +7784,8 @@ async function fetchManifest() {
   }
 }
 async function sha256File(path) {
-  const hash = (0, import_node_crypto.createHash)("sha256");
-  await (0, import_promises3.pipeline)((0, import_node_fs10.createReadStream)(path), hash);
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  await (0, import_promises3.pipeline)((0, import_node_fs11.createReadStream)(path), hash);
   return hash.digest("hex");
 }
 async function ensureEngine() {
@@ -7027,12 +7794,12 @@ async function ensureEngine() {
   noticeIfOutdated(manifest);
   const version = manifest?.engine_version || FALLBACK_ENGINE_VERSION;
   const dir = cacheDir(version);
-  const binPath = (0, import_node_path12.join)(dir, ENGINE_BINARY);
-  if ((0, import_node_fs10.existsSync)(binPath)) return binPath;
+  const binPath = (0, import_node_path13.join)(dir, ENGINE_BINARY);
+  if ((0, import_node_fs11.existsSync)(binPath)) return binPath;
   const artifact = manifest?.artifacts?.[key];
   const url = artifact?.url || `${APP_URL}/cli/engine/${version}/${key}${key.startsWith("darwin") ? ".zip" : ".tar.gz"}`;
-  (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
-  const archivePath = (0, import_node_path12.join)(dir, key.startsWith("darwin") ? "engine.zip" : "engine.tar.gz");
+  (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
+  const archivePath = (0, import_node_path13.join)(dir, key.startsWith("darwin") ? "engine.zip" : "engine.tar.gz");
   ui.step(`Preparing the ${brand.displayName} engine (first run only)\u2026`);
   const resp = await fetch(url, {
     redirect: "follow",
@@ -7046,11 +7813,11 @@ async function ensureEngine() {
       `Could not download the engine (HTTP ${resp.status}). Check your connection and try again.`
     );
   }
-  await (0, import_promises3.pipeline)(import_node_stream.Readable.fromWeb(resp.body), (0, import_node_fs10.createWriteStream)(archivePath));
+  await (0, import_promises3.pipeline)(import_node_stream.Readable.fromWeb(resp.body), (0, import_node_fs11.createWriteStream)(archivePath));
   if (artifact?.sha256) {
     const actual = await sha256File(archivePath);
     if (actual !== artifact.sha256) {
-      (0, import_node_fs10.rmSync)(archivePath, { force: true });
+      (0, import_node_fs11.rmSync)(archivePath, { force: true });
       throw new ApiError(
         0,
         "engine_checksum_mismatch",
@@ -7059,7 +7826,7 @@ async function ensureEngine() {
     }
   }
   const extract = archivePath.endsWith(".zip") ? (0, import_node_child_process3.spawnSync)("unzip", ["-oq", archivePath], { cwd: dir, stdio: "ignore" }) : (0, import_node_child_process3.spawnSync)("tar", ["-xzf", archivePath], { cwd: dir, stdio: "ignore" });
-  (0, import_node_fs10.rmSync)(archivePath, { force: true });
+  (0, import_node_fs11.rmSync)(archivePath, { force: true });
   if (extract.status !== 0) {
     throw new ApiError(
       0,
@@ -7067,24 +7834,24 @@ async function ensureEngine() {
       `Could not unpack the engine (needs ${archivePath.endsWith(".zip") ? "unzip" : "tar"} on PATH).`
     );
   }
-  const extracted = (0, import_node_path12.join)(dir, "opencode");
-  if ((0, import_node_fs10.existsSync)(extracted) && !(0, import_node_fs10.existsSync)(binPath)) (0, import_node_fs10.renameSync)(extracted, binPath);
-  if (!(0, import_node_fs10.existsSync)(binPath)) {
+  const extracted = (0, import_node_path13.join)(dir, "opencode");
+  if ((0, import_node_fs11.existsSync)(extracted) && !(0, import_node_fs11.existsSync)(binPath)) (0, import_node_fs11.renameSync)(extracted, binPath);
+  if (!(0, import_node_fs11.existsSync)(binPath)) {
     throw new ApiError(0, "engine_extract_failed", "Engine archive did not contain the expected binary.");
   }
-  (0, import_node_fs10.chmodSync)(binPath, 493);
+  (0, import_node_fs11.chmodSync)(binPath, 493);
   ui.ok(`Engine ready.`);
   console.log(paint.dim("  powered by opencode (MIT) \xB7 run `agentful licenses` for details"));
   return binPath;
 }
 
 // src/lib/gatewayToken.ts
-var import_node_fs11 = require("fs");
-var import_node_path13 = require("path");
-var cachePath = () => (0, import_node_path13.join)(configDir(), "gateway.json");
+var import_node_fs12 = require("fs");
+var import_node_path14 = require("path");
+var cachePath = () => (0, import_node_path14.join)(configDir(), "gateway.json");
 async function ensureGatewaySession(auth, projectId) {
   try {
-    const cached = JSON.parse((0, import_node_fs11.readFileSync)(cachePath(), "utf8"));
+    const cached = JSON.parse((0, import_node_fs12.readFileSync)(cachePath(), "utf8"));
     if (cached?.token && cached.expires_at - Date.now() / 1e3 > 3600) {
       return cached;
     }
@@ -7095,18 +7862,18 @@ async function ensureGatewaySession(auth, projectId) {
     body: projectId ? { project_id: projectId } : {},
     timeoutMs: 3e4
   });
-  (0, import_node_fs11.mkdirSync)(configDir(), { recursive: true });
-  (0, import_node_fs11.writeFileSync)(cachePath(), JSON.stringify(res, null, 2) + "\n", "utf8");
+  (0, import_node_fs12.mkdirSync)(configDir(), { recursive: true });
+  (0, import_node_fs12.writeFileSync)(cachePath(), JSON.stringify(res, null, 2) + "\n", "utf8");
   try {
-    (0, import_node_fs11.chmodSync)(cachePath(), 384);
+    (0, import_node_fs12.chmodSync)(cachePath(), 384);
   } catch {
   }
   return res;
 }
 
 // src/lib/engineConfig.ts
-var import_node_fs13 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs14 = require("fs");
+var import_node_path16 = require("path");
 var import_node_os5 = require("os");
 
 // src/branding/agentful-theme.json
@@ -7233,7 +8000,7 @@ var SLASH_COMMANDS = {
   },
   status: {
     description: `${brand.displayName}: show the linked project and account`,
-    template: "Run `agentful whoami` using the bash tool. Then read .agentful/project.json and report the linked project title and id, plus the preview URL https://preview-<projectId>.agentful.dev/. If the file does not exist, say that this directory is not linked yet and that `/setup` creates the link."
+    template: "Run `agentful whoami` using the bash tool. Then read .agentful/project.json and report the linked project title and id, plus the preview URL https://preview-<projectId>.agentful.page/. If the file does not exist, say that this directory is not linked yet and that `/setup` creates the link."
   }
 };
 function commandMarkdown(name) {
@@ -7249,22 +8016,22 @@ ${cmd.template}
 }
 
 // src/lib/tools.ts
-var import_node_fs12 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_path15 = require("path");
 function assetsDir() {
-  const here = (0, import_node_path14.dirname)(process.argv[1] || "");
-  for (const candidate of [(0, import_node_path14.join)(here, "..", "assets"), (0, import_node_path14.join)(here, "assets")]) {
-    if ((0, import_node_fs12.existsSync)((0, import_node_path14.join)(candidate, "tools", "imagegen.ts"))) return candidate;
+  const here = (0, import_node_path15.dirname)(process.argv[1] || "");
+  for (const candidate of [(0, import_node_path15.join)(here, "..", "assets"), (0, import_node_path15.join)(here, "assets")]) {
+    if ((0, import_node_fs13.existsSync)((0, import_node_path15.join)(candidate, "tools", "imagegen.ts"))) return candidate;
   }
   return null;
 }
 function installEngineTools(configDir2) {
   const assets = assetsDir();
   if (!assets) return false;
-  const target = (0, import_node_path14.join)(configDir2, "tools");
-  (0, import_node_fs12.mkdirSync)(target, { recursive: true });
+  const target = (0, import_node_path15.join)(configDir2, "tools");
+  (0, import_node_fs13.mkdirSync)(target, { recursive: true });
   try {
-    (0, import_node_fs12.cpSync)((0, import_node_path14.join)(assets, "tools"), target, { recursive: true });
+    (0, import_node_fs13.cpSync)((0, import_node_path15.join)(assets, "tools"), target, { recursive: true });
     return true;
   } catch {
     return false;
@@ -7274,7 +8041,7 @@ function installEngineTools(configDir2) {
 // src/lib/cloudTarget.ts
 var CLOUD_INSTRUCTIONS_FILENAME = "AGENTFUL_CLOUD.md";
 var FRAMEWORKS = contract_default.frameworks;
-function frameworkDisplayName(framework) {
+function frameworkDisplayName2(framework) {
   if (framework === "unknown") return "no supported framework";
   return FRAMEWORKS.find((f) => f.id === framework)?.display_name ?? framework;
 }
@@ -7287,7 +8054,7 @@ function frameworkTable() {
   return rows.join("\n");
 }
 function sessionLine(framework) {
-  const name = frameworkDisplayName(framework);
+  const name = frameworkDisplayName2(framework);
   switch (framework) {
     case "nextjs":
       return `Detected framework in this directory: **${name}** \u2014 next.config must keep \`output: 'export'\`; no route handlers/middleware/server actions.`;
@@ -7345,7 +8112,7 @@ function buildEnvList() {
 var bytes = (n) => n >= 1024 * 1024 ? `${n / (1024 * 1024)} MB` : `${n / 1024} KB`;
 function serverSideSection() {
   const tracks = contract_default.server_side;
-  const track = (key, heading, limits) => {
+  const track = (key, heading, limits2) => {
     const t = tracks[key];
     const out = [
       `### ${heading} ${t.label}`,
@@ -7359,7 +8126,7 @@ function serverSideSection() {
       "Does NOT offer \u2014 name the limit and offer the way out, never promise it:",
       ...t.not_offered.map((n) => `- **${n.what}.** ${n.why}. Way out: ${n.workaround}.`)
     ];
-    if (limits) out.push("", `Limits: ${limits}`);
+    if (limits2) out.push("", `Limits: ${limits2}`);
     if (t.limits_note) out.push("", t.limits_note);
     return out.join("\n");
   };
@@ -7568,7 +8335,7 @@ var CLOUD_AGENT_PROMPT = `You are the Agentful Cloud build agent: everything you
 var LOCAL_AGENT_PROMPT = `You are in local-only mode: free local development with no cloud deployment target \u2014 any stack is fine. Be clear that this directory will NOT be deployable with \`agentful push\` unless it satisfies the platform contract in AGENTFUL_CLOUD.md (${SERVER_SIDE_IN_ONE_SENTENCE}). If the user asks to deploy or push, check the contract first and say honestly whether the project can ship on the platform; never claim cloud deployability without evidence.`;
 function readAuthFile(path) {
   try {
-    return (0, import_node_fs13.readFileSync)(path, "utf8");
+    return (0, import_node_fs14.readFileSync)(path, "utf8");
   } catch {
     return null;
   }
@@ -7638,11 +8405,11 @@ function buildEngineConfig(opts) {
   };
 }
 function engineXdg() {
-  const root = (0, import_node_path15.join)((0, import_node_os5.homedir)(), ".local", "share", "agentful");
+  const root = (0, import_node_path16.join)((0, import_node_os5.homedir)(), ".local", "share", "agentful");
   return {
-    configHome: (0, import_node_path15.join)(root, "engine-config"),
-    dataHome: (0, import_node_path15.join)(root, "engine-data"),
-    stateHome: (0, import_node_path15.join)(root, "engine-state")
+    configHome: (0, import_node_path16.join)(root, "engine-config"),
+    dataHome: (0, import_node_path16.join)(root, "engine-data"),
+    stateHome: (0, import_node_path16.join)(root, "engine-state")
   };
 }
 async function resolveTheme() {
@@ -7661,24 +8428,24 @@ async function resolveTheme() {
 }
 async function writeEngineSession(session, catalog, localProviders = {}, framework = "unknown", skillsInstruction = null, backendState, model) {
   const xdg = engineXdg();
-  const configDir2 = (0, import_node_path15.join)(xdg.configHome, "opencode");
-  const dataDir = (0, import_node_path15.join)(xdg.dataHome, "opencode");
-  const themesDir = (0, import_node_path15.join)(configDir2, "themes");
-  const pluginsDir = (0, import_node_path15.join)(configDir2, "plugins");
-  const commandsDir = (0, import_node_path15.join)(configDir2, "commands");
-  for (const dir of [themesDir, pluginsDir, commandsDir, dataDir, (0, import_node_path15.join)(xdg.stateHome, "opencode")]) {
-    (0, import_node_fs13.mkdirSync)(dir, { recursive: true });
+  const configDir2 = (0, import_node_path16.join)(xdg.configHome, "opencode");
+  const dataDir = (0, import_node_path16.join)(xdg.dataHome, "opencode");
+  const themesDir = (0, import_node_path16.join)(configDir2, "themes");
+  const pluginsDir = (0, import_node_path16.join)(configDir2, "plugins");
+  const commandsDir = (0, import_node_path16.join)(configDir2, "commands");
+  for (const dir of [themesDir, pluginsDir, commandsDir, dataDir, (0, import_node_path16.join)(xdg.stateHome, "opencode")]) {
+    (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
   }
   const imagegenAvailable = installEngineTools(configDir2) && session.img_on !== false;
-  const cloudInstructionsPath = (0, import_node_path15.join)(configDir2, CLOUD_INSTRUCTIONS_FILENAME);
-  (0, import_node_fs13.writeFileSync)(cloudInstructionsPath, renderCloudInstructions(framework, backendState));
-  const skillsPath = (0, import_node_path15.join)(configDir2, "AGENTFUL_SKILLS.md");
+  const cloudInstructionsPath = (0, import_node_path16.join)(configDir2, CLOUD_INSTRUCTIONS_FILENAME);
+  (0, import_node_fs14.writeFileSync)(cloudInstructionsPath, renderCloudInstructions(framework, backendState));
+  const skillsPath = (0, import_node_path16.join)(configDir2, "AGENTFUL_SKILLS.md");
   const instructionPaths = [cloudInstructionsPath];
   if (skillsInstruction) {
-    (0, import_node_fs13.writeFileSync)(skillsPath, skillsInstruction);
+    (0, import_node_fs14.writeFileSync)(skillsPath, skillsInstruction);
     instructionPaths.push(skillsPath);
   } else {
-    (0, import_node_fs13.rmSync)(skillsPath, { force: true });
+    (0, import_node_fs14.rmSync)(skillsPath, { force: true });
   }
   const config = buildEngineConfig({
     session,
@@ -7688,13 +8455,13 @@ async function writeEngineSession(session, catalog, localProviders = {}, framewo
     instructionPaths,
     model
   });
-  (0, import_node_fs13.writeFileSync)((0, import_node_path15.join)(configDir2, "config.json"), JSON.stringify(config, null, 2));
-  const authPath2 = (0, import_node_path15.join)(dataDir, "auth.json");
-  (0, import_node_fs13.writeFileSync)(authPath2, mergedAuthJson(readAuthFile(authPath2), session.token));
+  (0, import_node_fs14.writeFileSync)((0, import_node_path16.join)(configDir2, "config.json"), JSON.stringify(config, null, 2));
+  const authPath2 = (0, import_node_path16.join)(dataDir, "auth.json");
+  (0, import_node_fs14.writeFileSync)(authPath2, mergedAuthJson(readAuthFile(authPath2), session.token));
   const { brandingPluginSource: brandingPluginSource2 } = await Promise.resolve().then(() => (init_plugin(), plugin_exports));
-  const pluginPath = (0, import_node_path15.join)(pluginsDir, "agentful-branding.tsx");
-  (0, import_node_fs13.writeFileSync)(pluginPath, brandingPluginSource2());
-  (0, import_node_fs13.writeFileSync)((0, import_node_path15.join)(configDir2, "tui.json"), JSON.stringify({
+  const pluginPath = (0, import_node_path16.join)(pluginsDir, "agentful-branding.tsx");
+  (0, import_node_fs14.writeFileSync)(pluginPath, brandingPluginSource2());
+  (0, import_node_fs14.writeFileSync)((0, import_node_path16.join)(configDir2, "tui.json"), JSON.stringify({
     theme: "agentful",
     plugin: [`file://${pluginPath}`],
     // The engine's own sidebar sections are plugins with fixed ids, and
@@ -7706,13 +8473,13 @@ async function writeEngineSession(session, catalog, localProviders = {}, framewo
     // state over this map.
     plugin_enabled: DISABLED_ENGINE_PLUGINS
   }, null, 2));
-  (0, import_node_fs13.writeFileSync)((0, import_node_path15.join)(themesDir, "agentful.json"), JSON.stringify(await resolveTheme(), null, 2));
+  (0, import_node_fs14.writeFileSync)((0, import_node_path16.join)(themesDir, "agentful.json"), JSON.stringify(await resolveTheme(), null, 2));
   for (const name of Object.keys(SLASH_COMMANDS)) {
-    (0, import_node_fs13.writeFileSync)((0, import_node_path15.join)(commandsDir, `${name}.md`), commandMarkdown(name));
+    (0, import_node_fs14.writeFileSync)((0, import_node_path16.join)(commandsDir, `${name}.md`), commandMarkdown(name));
   }
   for (const legacy of ["xdg-config", "xdg-data", "xdg-state"]) {
     try {
-      (0, import_node_fs13.rmSync)((0, import_node_path15.join)((0, import_node_os5.homedir)(), ".local", "share", "agentful", legacy), { recursive: true, force: true });
+      (0, import_node_fs14.rmSync)((0, import_node_path16.join)((0, import_node_os5.homedir)(), ".local", "share", "agentful", legacy), { recursive: true, force: true });
     } catch {
     }
   }
@@ -7720,8 +8487,8 @@ async function writeEngineSession(session, catalog, localProviders = {}, framewo
 }
 
 // src/lib/skills.ts
-var import_node_fs14 = require("fs");
-var import_node_path16 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path17 = require("path");
 
 // src/generated/skills.json
 var skills_default = {
@@ -7790,7 +8557,7 @@ var SCAFFOLD_BY_FRAMEWORK = {
 };
 function hasVueDependency(rootDir) {
   try {
-    const pkg = JSON.parse((0, import_node_fs14.readFileSync)((0, import_node_path16.join)(rootDir, "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs15.readFileSync)((0, import_node_path17.join)(rootDir, "package.json"), "utf8"));
     return Boolean({ ...pkg.dependencies, ...pkg.devDependencies }["vue"]);
   } catch {
     return false;
@@ -7820,7 +8587,7 @@ function renderSkillsInstruction(names) {
   return "# Platform deployment skills (mandatory)\n\nThese are the same skills the cloud build agent loads for this stack.\nFollow them when scaffolding or editing \u2014 they are not optional hints.\n\n" + sections.join("\n\n---\n\n") + "\n";
 }
 function skillsInstructionFor(framework, rootDir) {
-  if (!(0, import_node_fs14.existsSync)(rootDir)) return null;
+  if (!(0, import_node_fs15.existsSync)(rootDir)) return null;
   return renderSkillsInstruction(selectSkills(framework, rootDir));
 }
 
@@ -7979,15 +8746,15 @@ function decideLocalProviders(policy) {
 }
 
 // src/lib/localProviders.ts
-var import_node_fs15 = require("fs");
-var import_node_path17 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path18 = require("path");
 var LOCAL_PROVIDERS_FILE = "local-providers.json";
 function localProvidersPath() {
-  return (0, import_node_path17.join)(configDir(), LOCAL_PROVIDERS_FILE);
+  return (0, import_node_path18.join)(configDir(), LOCAL_PROVIDERS_FILE);
 }
 function readLocalProviders() {
   try {
-    const raw = JSON.parse((0, import_node_fs15.readFileSync)(localProvidersPath(), "utf8"));
+    const raw = JSON.parse((0, import_node_fs16.readFileSync)(localProvidersPath(), "utf8"));
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       const map = raw.providers && typeof raw.providers === "object" ? raw.providers : raw;
       const usable = {};
@@ -8022,8 +8789,8 @@ function resolveLocalProviders(policy) {
 }
 function writeLocalProvidersExample() {
   const path = localProvidersPath();
-  if ((0, import_node_fs15.existsSync)(path)) return path;
-  (0, import_node_fs15.mkdirSync)(configDir(), { recursive: true });
+  if ((0, import_node_fs16.existsSync)(path)) return path;
+  (0, import_node_fs16.mkdirSync)(configDir(), { recursive: true });
   const example = {
     _comment: 'Providers with your own API key, running locally. Requests go directly to the provider \u2014 no Agentful credits, no platform region guarantee. Remove the leading underscore from "_anthropic" and fill in your key to enable it.',
     _anthropic: {
@@ -8033,17 +8800,17 @@ function writeLocalProvidersExample() {
       models: { "claude-sonnet-4-5": { name: "Claude Sonnet 4.5 (my key)" } }
     }
   };
-  (0, import_node_fs15.writeFileSync)(path, JSON.stringify(example, null, 2) + "\n", "utf8");
+  (0, import_node_fs16.writeFileSync)(path, JSON.stringify(example, null, 2) + "\n", "utf8");
   try {
-    (0, import_node_fs15.chmodSync)(path, 384);
+    (0, import_node_fs16.chmodSync)(path, 384);
   } catch {
   }
   return path;
 }
 
 // src/lib/sessions.ts
-var import_node_fs16 = require("fs");
-var import_node_path18 = require("path");
+var import_node_fs17 = require("fs");
+var import_node_path19 = require("path");
 var import_node_child_process4 = require("child_process");
 function parseSessionModel(raw) {
   if (!raw) return null;
@@ -8060,8 +8827,8 @@ function parseSessionModel(raw) {
   }
 }
 function modelForSession(sessionID) {
-  const dbPath = (0, import_node_path18.join)(engineXdg().dataHome, "opencode", "opencode.db");
-  if (!(0, import_node_fs16.existsSync)(dbPath)) return null;
+  const dbPath = (0, import_node_path19.join)(engineXdg().dataHome, "opencode", "opencode.db");
+  if (!(0, import_node_fs17.existsSync)(dbPath)) return null;
   const escaped = sessionID.replace(/'/g, "''");
   const res = (0, import_node_child_process4.spawnSync)(
     "sqlite3",
@@ -8082,8 +8849,8 @@ function modelForSession(sessionID) {
   }
 }
 function lastSessionForDirectory(cwd = process.cwd()) {
-  const dbPath = (0, import_node_path18.join)(engineXdg().dataHome, "opencode", "opencode.db");
-  if (!(0, import_node_fs16.existsSync)(dbPath)) return null;
+  const dbPath = (0, import_node_path19.join)(engineXdg().dataHome, "opencode", "opencode.db");
+  if (!(0, import_node_fs17.existsSync)(dbPath)) return null;
   const escaped = cwd.replace(/'/g, "''");
   const res = (0, import_node_child_process4.spawnSync)(
     "sqlite3",
@@ -8109,9 +8876,9 @@ function lastSessionForDirectory(cwd = process.cwd()) {
 }
 
 // src/lib/modelPin.ts
-var import_node_fs17 = require("fs");
-var import_node_path19 = require("path");
-var PROJECT_MODEL_PIN = (0, import_node_path19.join)(".agentful", "model.json");
+var import_node_fs18 = require("fs");
+var import_node_path20 = require("path");
+var PROJECT_MODEL_PIN = (0, import_node_path20.join)(".agentful", "model.json");
 function isCanonicalModel(value) {
   const slash = value.indexOf("/");
   return slash > 0 && slash < value.length - 1 && !/\s/.test(value);
@@ -8131,10 +8898,10 @@ function assertModelPin(pin, source) {
   return pin;
 }
 function readProjectModelPin(cwd = process.cwd()) {
-  const path = (0, import_node_path19.join)(cwd, PROJECT_MODEL_PIN);
+  const path = (0, import_node_path20.join)(cwd, PROJECT_MODEL_PIN);
   let raw;
   try {
-    raw = (0, import_node_fs17.readFileSync)(path, "utf8");
+    raw = (0, import_node_fs18.readFileSync)(path, "utf8");
   } catch (error) {
     const code = error.code;
     if (code === "ENOENT") return null;
@@ -8161,7 +8928,7 @@ function readProjectModelPin(cwd = process.cwd()) {
 function readEngineVariants(xdg) {
   try {
     const parsed = JSON.parse(
-      (0, import_node_fs17.readFileSync)((0, import_node_path19.join)(xdg.stateHome, "opencode", "model.json"), "utf8")
+      (0, import_node_fs18.readFileSync)((0, import_node_path20.join)(xdg.stateHome, "opencode", "model.json"), "utf8")
     );
     if (!parsed.variant || typeof parsed.variant !== "object" || Array.isArray(parsed.variant)) return {};
     return Object.fromEntries(
@@ -8173,17 +8940,17 @@ function readEngineVariants(xdg) {
 }
 function writeEngineVariant(xdg, model, variant) {
   assertModelPin({ model, variant }, "Selected");
-  const path = (0, import_node_path19.join)(xdg.stateHome, "opencode", "model.json");
+  const path = (0, import_node_path20.join)(xdg.stateHome, "opencode", "model.json");
   let state = {};
   try {
-    const parsed = JSON.parse((0, import_node_fs17.readFileSync)(path, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs18.readFileSync)(path, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) state = parsed;
   } catch {
   }
   const existing = state.variant;
   const variants = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
   state.variant = { ...variants, [model]: variant };
-  (0, import_node_fs17.writeFileSync)(path, JSON.stringify(state, null, 2) + "\n", "utf8");
+  (0, import_node_fs18.writeFileSync)(path, JSON.stringify(state, null, 2) + "\n", "utf8");
 }
 function resolveModelPin(opts) {
   const cliPin = opts.cliModel ? assertModelPin({ model: opts.cliModel, variant: opts.cliVariant }, "CLI") : null;
@@ -8232,8 +8999,8 @@ function resolveModelPin(opts) {
 // src/lib/engineModels.ts
 var import_node_child_process5 = require("child_process");
 var import_node_util = require("util");
-var import_node_fs18 = require("fs");
-var import_node_path20 = require("path");
+var import_node_fs19 = require("fs");
+var import_node_path21 = require("path");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process5.execFile);
 function parseEngineModelsOutput(output) {
   return Array.from(new Set(
@@ -8284,7 +9051,7 @@ async function assertEngineModelAvailable(binPath, xdg, model, listModels = list
 function readConnectedEngineProviders(xdg) {
   try {
     const parsed = JSON.parse(
-      (0, import_node_fs18.readFileSync)((0, import_node_path20.join)(xdg.dataHome, "opencode", "auth.json"), "utf8")
+      (0, import_node_fs19.readFileSync)((0, import_node_path21.join)(xdg.dataHome, "opencode", "auth.json"), "utf8")
     );
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return Object.keys(parsed).filter((id) => id !== "agentful").sort();
@@ -8315,7 +9082,7 @@ function describeModelRoute(model, catalog, localProviders, connectedProviders)
 }
 
 // src/lib/engineEvents.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_node_net = require("net");
 function payloadOf(event) {
   return event.payload && typeof event.payload === "object" ? event.payload : event;
@@ -8441,7 +9208,7 @@ var EngineLivenessPolicy = class {
 function engineServerCredentials(env = process.env) {
   return {
     username: env.OPENCODE_SERVER_USERNAME || void 0,
-    password: env.OPENCODE_SERVER_PASSWORD || (0, import_node_crypto2.randomUUID)()
+    password: env.OPENCODE_SERVER_PASSWORD || (0, import_node_crypto3.randomUUID)()
   };
 }
 async function reserveLoopbackPort() {
@@ -8646,7 +9413,7 @@ async function tuiCommand(opts = {}) {
     ));
   } else {
     ui.info(paint.dim(
-      `Mode: ${CLOUD_AGENT} \u2014 building for Agentful Cloud (${frameworkDisplayName(framework)}). Tab switches to ${LOCAL_AGENT} for work that is not meant to deploy.`
+      `Mode: ${CLOUD_AGENT} \u2014 building for Agentful Cloud (${frameworkDisplayName2(framework)}). Tab switches to ${LOCAL_AGENT} for work that is not meant to deploy.`
     ));
   }
   const localCount = Object.keys(local.providers).length;
@@ -8720,7 +9487,7 @@ async function tuiCommand(opts = {}) {
           ...process.env,
           // Slash commands run `agentful …` through the agent's bash tool, which
           // has no access to the user's shell aliases.
-          PATH: `${binDir}${import_node_path21.delimiter}${process.env.PATH || ""}`,
+          PATH: `${binDir}${import_node_path22.delimiter}${process.env.PATH || ""}`,
           XDG_CONFIG_HOME: xdg.configHome,
           XDG_DATA_HOME: xdg.dataHome,
           XDG_STATE_HOME: xdg.stateHome,
@@ -8854,38 +9621,38 @@ async function shareCommand(opts) {
 }
 
 // src/commands/pull.ts
-var import_node_fs20 = require("fs");
-var import_node_path23 = require("path");
+var import_node_fs21 = require("fs");
+var import_node_path24 = require("path");
 init_branding();
 init_branding();
 
 // src/lib/pullFiles.ts
-var import_node_fs19 = require("fs");
-var import_node_path22 = require("path");
+var import_node_fs20 = require("fs");
+var import_node_path23 = require("path");
 var INLINE_BASE64_EXTENSIONS = /\.(?:png|jpe?g|gif|webp|avif|svg|ico|bmp|tiff?|woff2?|ttf|otf|eot|pdf|docx?|xlsx?|pptx?|zip|tar|gz|7z|rar|bz2|mp[34]|m4a|wav|ogg|avi|mov|mkv|flac|webm|exe|dll|so|dylib|bin|wasm)$/i;
 function inlineContent(value) {
   return typeof value === "object" && value !== null && "content" in value ? String(value.content) : String(value ?? "");
 }
 function writePulledWorkspaceEntry(root, rel, value) {
-  const target = (0, import_node_path22.join)(root, rel);
-  (0, import_node_fs19.mkdirSync)((0, import_node_path22.dirname)(target), { recursive: true });
+  const target = (0, import_node_path23.join)(root, rel);
+  (0, import_node_fs20.mkdirSync)((0, import_node_path23.dirname)(target), { recursive: true });
   const content = inlineContent(value);
   if (INLINE_BASE64_EXTENSIONS.test(rel)) {
-    (0, import_node_fs19.writeFileSync)(target, Buffer.from(content, "base64"));
+    (0, import_node_fs20.writeFileSync)(target, Buffer.from(content, "base64"));
     return;
   }
-  (0, import_node_fs19.writeFileSync)(target, content, "utf8");
+  (0, import_node_fs20.writeFileSync)(target, content, "utf8");
 }
 function writePulledBackendDeclaration(root, declaration) {
-  const target = (0, import_node_path22.join)(root, ".agentful", "backend.json");
-  (0, import_node_fs19.mkdirSync)((0, import_node_path22.dirname)(target), { recursive: true });
+  const target = (0, import_node_path23.join)(root, ".agentful", "backend.json");
+  (0, import_node_fs20.mkdirSync)((0, import_node_path23.dirname)(target), { recursive: true });
   const {
     source: _source,
     received_at: _receivedAt,
     last_sync: _lastSync,
     ...portableDeclaration
   } = declaration;
-  (0, import_node_fs19.writeFileSync)(target, `${JSON.stringify(portableDeclaration, null, 2)}
+  (0, import_node_fs20.writeFileSync)(target, `${JSON.stringify(portableDeclaration, null, 2)}
 `, "utf8");
 }
 
@@ -8894,7 +9661,7 @@ async function pullCommand(opts) {
   console.log(banner());
   const auth = await ensureAuth();
   const project = requireProject();
-  const nonHidden = (0, import_node_fs20.readdirSync)(process.cwd()).filter((n) => n !== ".agentful" && !n.startsWith("."));
+  const nonHidden = (0, import_node_fs21.readdirSync)(process.cwd()).filter((n) => n !== ".agentful" && !n.startsWith("."));
   if (nonHidden.length > 0 && !opts.force) {
     throw new ApiError(
       0,
@@ -8921,9 +9688,9 @@ async function pullCommand(opts) {
         ui.warn(`Skipped ${rel} (HTTP ${resp.status})`);
         continue;
       }
-      const target = (0, import_node_path23.join)(process.cwd(), rel);
-      (0, import_node_fs20.mkdirSync)((0, import_node_path23.dirname)(target), { recursive: true });
-      (0, import_node_fs20.writeFileSync)(target, Buffer.from(await resp.arrayBuffer()));
+      const target = (0, import_node_path24.join)(process.cwd(), rel);
+      (0, import_node_fs21.mkdirSync)((0, import_node_path24.dirname)(target), { recursive: true });
+      (0, import_node_fs21.writeFileSync)(target, Buffer.from(await resp.arrayBuffer()));
       written++;
     }
   } else if (data.files) {
@@ -9128,7 +9895,7 @@ program2.command("login").description("Sign in to your Agentful account (device
 program2.command("logout").description("Remove the stored credentials").action(run(logoutCommand));
 program2.command("whoami").description("Show the signed-in account").action(run(whoamiCommand));
 program2.command("init").description("Create (or link) the Agentful cloud project for this directory").argument("[directory]", "with --template: new folder to scaffold into (created for you)").option("--link <projectId>", "link an existing project instead of creating one").option("--title <title>", "project title (skips the prompt)").option("--template <framework>", "scaffold from a platform starter (nextjs, react, vue, vanilla)").action(run((directory, opts) => initCommand(opts, directory)));
-program2.command("push").description("Upload this project and get a live preview URL").option("--prebuilt", "upload a locally built output instead of building in the cloud").option("--dir <path>", "built-output directory for --prebuilt (default: auto-detect)").option("--force", "push even when the pre-upload compatibility check finds blocking issues").option("-y, --yes", "enable the declared managed database without asking (CI); a non-interactive push never enables it").action(run((opts) => pushCommand(opts)));
+program2.command("push").description("Upload this project and get a live preview URL").option("--prebuilt", "upload a locally built output instead of building in the cloud").option("--dir <path>", "built-output directory for --prebuilt (default: auto-detect)").option("--force", "push even when the pre-upload compatibility check finds blocking issues").option("-y, --yes", "enable the declared managed database without asking (CI); a non-interactive push never enables it").option("--dry-run", "analyse only: what would be uploaded, how large, and what would block it \u2014 no sign-in, no project, no upload").option("--json", "with --dry-run: print the analysis as JSON (for scripts and agents)").action(run((opts) => pushCommand(opts)));
 program2.command("build-status").description("Show the cloud's record of the last build (the real error on failures)").action(run(buildStatusCommand));
 program2.command("backend").description("Open this project's Backend tab (managed DB + server actions) in the browser").action(run(backendCommand));
 program2.command("open").description("Open the live preview in the browser").action(run(openCommand));