@usefillo/cli 0.9.0 → 0.12.0

package/dist/index.js

@@ -1298,79 +1298,122 @@ var CONTENT_KINDS = ["heading", "paragraph", "divider"];
 function isField(block) {
   return !CONTENT_KINDS.includes(block.kind);
 }
-var C = (iso2, name, dialCode, lengths = [], groups = [], example = "") => ({ iso2, name, dialCode, lengths, groups, example });
+var regionNames;
+function regionDisplayNames() {
+  if (regionNames !== void 0) return regionNames ?? void 0;
+  if (typeof Intl === "undefined" || typeof Intl.DisplayNames === "undefined") {
+    regionNames = null;
+    return void 0;
+  }
+  try {
+    regionNames = new Intl.DisplayNames(void 0, { type: "region" });
+  } catch {
+    regionNames = null;
+  }
+  return regionNames ?? void 0;
+}
+function regionName(iso2) {
+  try {
+    return regionDisplayNames()?.of(iso2) ?? iso2;
+  } catch {
+    return iso2;
+  }
+}
+var C = (iso2, dialCode, lengths = [], groups = [], example = "") => ({ iso2, name: regionName(iso2), dialCode, lengths, groups, example });
+var CURATED_COUNTRIES = [
+  C("US", "1", [10], [3, 3, 4], "2015550123"),
+  C("CA", "1", [10], [3, 3, 4], "5145550123"),
+  C("GB", "44", [10], [4, 6], "7400123456"),
+  C("AU", "61", [9], [3, 3, 3], "412345678"),
+  C("DE", "49", [10, 11], [4, 7], "15123456789"),
+  C("FR", "33", [9], [1, 2, 2, 2, 2], "612345678"),
+  C("IN", "91", [10], [5, 5], "8123456789"),
+  C("DK", "45", [8], [2, 2, 2, 2], "32123456"),
+  C("SE", "46", [9], [2, 3, 4], "701234567"),
+  C("NO", "47", [8], [3, 2, 3], "40612345"),
+  C("FI", "358", [9, 10], [2, 3, 4], "412345678"),
+  C("NL", "31", [9], [1, 4, 4], "612345678"),
+  C("BE", "32", [9], [3, 2, 2, 2], "470123456"),
+  C("ES", "34", [9], [3, 3, 3], "612345678"),
+  C("IT", "39", [9, 10], [3, 3, 4], "3123456789"),
+  C("PT", "351", [9], [3, 3, 3], "912345678"),
+  C("IE", "353", [9], [2, 3, 4], "851234567"),
+  C("CH", "41", [9], [2, 3, 2, 2], "781234567"),
+  C("AT", "43", [10, 11], [3, 7], "6641234567"),
+  C("PL", "48", [9], [3, 3, 3], "512345678"),
+  C("CZ", "420", [9], [3, 3, 3], "601123456"),
+  C("GR", "30", [10], [3, 3, 4], "6912345678"),
+  C("RO", "40", [9], [3, 3, 3], "712345678"),
+  C("HU", "36", [9], [2, 3, 4], "201234567"),
+  C("UA", "380", [9], [2, 3, 2, 2], "501234567"),
+  C("RU", "7", [10], [3, 3, 2, 2], "9123456789"),
+  C("TR", "90", [10], [3, 3, 2, 2], "5012345678"),
+  C("IL", "972", [9], [2, 3, 4], "501234567"),
+  C("AE", "971", [9], [2, 3, 4], "501234567"),
+  C("SA", "966", [9], [2, 3, 4], "512345678"),
+  C("ZA", "27", [9], [2, 3, 4], "711234567"),
+  C("NG", "234", [10], [3, 3, 4], "8021234567"),
+  C("KE", "254", [9], [3, 3, 3], "712123456"),
+  C("EG", "20", [10], [3, 3, 4], "1001234567"),
+  C("BR", "55", [10, 11], [2, 5, 4], "11961234567"),
+  C("MX", "52", [10], [3, 3, 4], "2221234567"),
+  C("AR", "54", [10], [4, 6], "1123456789"),
+  C("CL", "56", [9], [1, 4, 4], "221234567"),
+  C("CO", "57", [10], [3, 3, 4], "3211234567"),
+  C("PE", "51", [9], [3, 3, 3], "912345678"),
+  C("CN", "86", [11], [3, 4, 4], "13123456789"),
+  C("JP", "81", [10], [2, 4, 4], "9012345678"),
+  C("KR", "82", [9, 10], [2, 4, 4], "1023456789"),
+  C("SG", "65", [8], [4, 4], "81234567"),
+  C("HK", "852", [8], [4, 4], "51234567"),
+  C("TW", "886", [9], [3, 3, 3], "912345678"),
+  C("MY", "60", [9, 10], [2, 3, 4], "123456789"),
+  C("ID", "62", [10, 11], [3, 4, 4], "81234567890"),
+  C("TH", "66", [9], [2, 3, 4], "812345678"),
+  C("PH", "63", [10], [3, 3, 4], "9171234567"),
+  C("VN", "84", [9], [3, 3, 3], "912345678"),
+  C("PK", "92", [10], [3, 3, 4], "3012345678"),
+  C("BD", "880", [10], [2, 4, 4], "1812345678"),
+  C("NZ", "64", [9, 10], [2, 3, 4], "211234567"),
+  C("SK", "421", [9], [3, 3, 3], "912123456"),
+  C("BG", "359", [9], [2, 3, 4], "481234567"),
+  C("HR", "385", [8, 9], [2, 3, 4], "921234567"),
+  C("RS", "381", [8, 9], [2, 3, 4], "601234567"),
+  C("SI", "386", [8], [2, 3, 3], "31234567"),
+  C("LT", "370", [8], [3, 2, 3], "61234567"),
+  C("LV", "371", [8], [2, 3, 3], "21234567"),
+  C("EE", "372", [7, 8], [3, 4], "51234567"),
+  C("IS", "354", [7], [3, 4], "6111234"),
+  C("LU", "352", [9], [3, 3, 3], "628123456"),
+  C("MA", "212", [9], [3, 3, 3], "650123456"),
+  C("CR", "506", [8], [4, 4], "83123456"),
+  C("EC", "593", [9], [2, 3, 4], "991234567"),
+  C("UY", "598", [8], [1, 3, 4], "94231234"),
+  C("QA", "974", [8], [4, 4], "33123456"),
+  C("KW", "965", [8], [4, 4], "50012345")
+];
+var PACKED_DIAL_CODES = "AD376 AF93 AG1 AI1 AL355 AM374 AO244 AS1 AW297 AX358 AZ994 BA387 BB1 BF226 BH973 BI257 BJ229 BL590 BM1 BN673 BO591 BQ599 BS1 BT975 BV47 BW267 BY375 BZ501 CC61 CD243 CF236 CG242 CI225 CK682 CM237 CU53 CV238 CW599 CX61 CY357 DJ253 DM1 DO1 DZ213 EH212 ER291 ET251 FJ679 FK500 FM691 FO298 GA241 GD1 GE995 GF594 GG44 GH233 GI350 GL299 GM220 GN224 GP590 GQ240 GS500 GT502 GU1 GW245 GY592 HN504 HT509 IM44 IO246 IQ964 IR98 JE44 JM1 JO962 KG996 KH855 KI686 KM269 KN1 KP850 KY1 KZ7 LA856 LB961 LC1 LI423 LK94 LR231 LS266 LY218 MC377 MD373 ME382 MF590 MG261 MH692 MK389 ML223 MM95 MN976 MO853 MP1 MQ596 MR222 MS1 MT356 MU230 MV960 MW265 MZ258 NA264 NC687 NE227 NF672 NI505 NP977 NR674 NU683 OM968 PA507 PF689 PG675 PM508 PN64 PR1 PS970 PW680 PY595 RE262 RW250 SB677 SC248 SD249 SH290 SJ47 SL232 SM378 SN221 SO252 SR597 SS211 ST239 SV503 SX1 SY963 SZ268 TC1 TD235 TF262 TG228 TJ992 TK690 TL670 TM993 TN216 TO676 TT1 TV688 TZ255 UG256 UZ998 VA379 VC1 VE58 VG1 VI1 VU678 WF681 WS685 XK383 YE967 YT262 ZM260 ZW263";
+function parsePackedCountries(packed) {
+  const out = [];
+  for (const token of packed.trim().split(/\s+/)) {
+    const iso2 = token.slice(0, 2);
+    const dialCode = token.slice(2);
+    out.push({ iso2, name: regionName(iso2), dialCode, lengths: [], groups: [], example: "" });
+  }
+  return out;
+}
 var PHONE_COUNTRIES = [
-  C("US", "United States", "1", [10], [3, 3, 4], "2015550123"),
-  C("CA", "Canada", "1", [10], [3, 3, 4], "5145550123"),
-  C("GB", "United Kingdom", "44", [10], [4, 6], "7400123456"),
-  C("AU", "Australia", "61", [9], [3, 3, 3], "412345678"),
-  C("DE", "Germany", "49", [10, 11], [4, 7], "15123456789"),
-  C("FR", "France", "33", [9], [1, 2, 2, 2, 2], "612345678"),
-  C("IN", "India", "91", [10], [5, 5], "8123456789"),
-  C("DK", "Denmark", "45", [8], [2, 2, 2, 2], "32123456"),
-  C("SE", "Sweden", "46", [9], [2, 3, 4], "701234567"),
-  C("NO", "Norway", "47", [8], [3, 2, 3], "40612345"),
-  C("FI", "Finland", "358", [9, 10], [2, 3, 4], "412345678"),
-  C("NL", "Netherlands", "31", [9], [1, 4, 4], "612345678"),
-  C("BE", "Belgium", "32", [9], [3, 2, 2, 2], "470123456"),
-  C("ES", "Spain", "34", [9], [3, 3, 3], "612345678"),
-  C("IT", "Italy", "39", [9, 10], [3, 3, 4], "3123456789"),
-  C("PT", "Portugal", "351", [9], [3, 3, 3], "912345678"),
-  C("IE", "Ireland", "353", [9], [2, 3, 4], "851234567"),
-  C("CH", "Switzerland", "41", [9], [2, 3, 2, 2], "781234567"),
-  C("AT", "Austria", "43", [10, 11], [3, 7], "6641234567"),
-  C("PL", "Poland", "48", [9], [3, 3, 3], "512345678"),
-  C("CZ", "Czechia", "420", [9], [3, 3, 3], "601123456"),
-  C("GR", "Greece", "30", [10], [3, 3, 4], "6912345678"),
-  C("RO", "Romania", "40", [9], [3, 3, 3], "712345678"),
-  C("HU", "Hungary", "36", [9], [2, 3, 4], "201234567"),
-  C("UA", "Ukraine", "380", [9], [2, 3, 2, 2], "501234567"),
-  C("RU", "Russia", "7", [10], [3, 3, 2, 2], "9123456789"),
-  C("TR", "Turkey", "90", [10], [3, 3, 2, 2], "5012345678"),
-  C("IL", "Israel", "972", [9], [2, 3, 4], "501234567"),
-  C("AE", "United Arab Emirates", "971", [9], [2, 3, 4], "501234567"),
-  C("SA", "Saudi Arabia", "966", [9], [2, 3, 4], "512345678"),
-  C("ZA", "South Africa", "27", [9], [2, 3, 4], "711234567"),
-  C("NG", "Nigeria", "234", [10], [3, 3, 4], "8021234567"),
-  C("KE", "Kenya", "254", [9], [3, 3, 3], "712123456"),
-  C("EG", "Egypt", "20", [10], [3, 3, 4], "1001234567"),
-  C("BR", "Brazil", "55", [10, 11], [2, 5, 4], "11961234567"),
-  C("MX", "Mexico", "52", [10], [3, 3, 4], "2221234567"),
-  C("AR", "Argentina", "54", [10], [4, 6], "1123456789"),
-  C("CL", "Chile", "56", [9], [1, 4, 4], "221234567"),
-  C("CO", "Colombia", "57", [10], [3, 3, 4], "3211234567"),
-  C("PE", "Peru", "51", [9], [3, 3, 3], "912345678"),
-  C("CN", "China", "86", [11], [3, 4, 4], "13123456789"),
-  C("JP", "Japan", "81", [10], [2, 4, 4], "9012345678"),
-  C("KR", "South Korea", "82", [9, 10], [2, 4, 4], "1023456789"),
-  C("SG", "Singapore", "65", [8], [4, 4], "81234567"),
-  C("HK", "Hong Kong", "852", [8], [4, 4], "51234567"),
-  C("TW", "Taiwan", "886", [9], [3, 3, 3], "912345678"),
-  C("MY", "Malaysia", "60", [9, 10], [2, 3, 4], "123456789"),
-  C("ID", "Indonesia", "62", [10, 11], [3, 4, 4], "81234567890"),
-  C("TH", "Thailand", "66", [9], [2, 3, 4], "812345678"),
-  C("PH", "Philippines", "63", [10], [3, 3, 4], "9171234567"),
-  C("VN", "Vietnam", "84", [9], [3, 3, 3], "912345678"),
-  C("PK", "Pakistan", "92", [10], [3, 3, 4], "3012345678"),
-  C("BD", "Bangladesh", "880", [10], [2, 4, 4], "1812345678"),
-  C("NZ", "New Zealand", "64", [9, 10], [2, 3, 4], "211234567"),
-  C("SK", "Slovakia", "421", [9], [3, 3, 3], "912123456"),
-  C("BG", "Bulgaria", "359", [9], [2, 3, 4], "481234567"),
-  C("HR", "Croatia", "385", [8, 9], [2, 3, 4], "921234567"),
-  C("RS", "Serbia", "381", [8, 9], [2, 3, 4], "601234567"),
-  C("SI", "Slovenia", "386", [8], [2, 3, 3], "31234567"),
-  C("LT", "Lithuania", "370", [8], [3, 2, 3], "61234567"),
-  C("LV", "Latvia", "371", [8], [2, 3, 3], "21234567"),
-  C("EE", "Estonia", "372", [7, 8], [3, 4], "51234567"),
-  C("IS", "Iceland", "354", [7], [3, 4], "6111234"),
-  C("LU", "Luxembourg", "352", [9], [3, 3, 3], "628123456"),
-  C("MA", "Morocco", "212", [9], [3, 3, 3], "650123456"),
-  C("CR", "Costa Rica", "506", [8], [4, 4], "83123456"),
-  C("EC", "Ecuador", "593", [9], [2, 3, 4], "991234567"),
-  C("UY", "Uruguay", "598", [8], [1, 3, 4], "94231234"),
-  C("QA", "Qatar", "974", [8], [4, 4], "33123456"),
-  C("KW", "Kuwait", "965", [8], [4, 4], "50012345")
+  ...CURATED_COUNTRIES,
+  ...parsePackedCountries(PACKED_DIAL_CODES)
 ];
+var PHONE_PICKER_COUNTRIES = sortForPicker(PHONE_COUNTRIES);
+function sortForPicker(countries) {
+  if (typeof Intl === "undefined" || typeof Intl.Collator === "undefined") {
+    return [...countries].sort((a, b) => a.iso2 < b.iso2 ? -1 : a.iso2 > b.iso2 ? 1 : 0);
+  }
+  const collator = new Intl.Collator(void 0, { sensitivity: "base" });
+  return [...countries].sort((a, b) => collator.compare(a.name, b.name));
+}
 var byIso = new Map(PHONE_COUNTRIES.map((c) => [c.iso2, c]));
 var fileValueSchema = object({
   fileId: string2().check(_minLength(1)),
@@ -1398,6 +1441,7 @@ var FIELD_KINDS = [
   "date",
   "file_upload",
   "hidden",
+  "calculated",
   "custom"
 ];
 var CONTENT_KINDS2 = ["heading", "paragraph", "divider"];
@@ -1434,7 +1478,7 @@ var schemaShape = object({
 });
 var MAX_SCHEMA_VERSION = 1;
 var FILLO_SCHEMA_VERSION = 1;
-var FILLO_SDK_VERSION = true ? "0.9.0" : "0.0.0-dev";
+var FILLO_SDK_VERSION = true ? "0.12.0" : "0.0.0-dev";
 function str(value, max, fallback = "") {
   return typeof value === "string" ? value.trim().slice(0, max) : fallback;
 }
@@ -1442,6 +1486,11 @@ function optionalStr(value, max) {
   const s = str(value, max);
   return s === "" ? void 0 : s;
 }
+function optionalAffix(value, max) {
+  if (typeof value !== "string") return void 0;
+  const s = value.slice(0, max);
+  return s.trim() === "" ? void 0 : s;
+}
 function bool(value) {
   return typeof value === "boolean" ? value : void 0;
 }
@@ -1489,7 +1538,17 @@ function conditions(value) {
   });
   return normalized.length ? normalized : void 0;
 }
-function jumpRules(value, pageIds, sourceId, allowedFieldIds) {
+function jumpDepsAllowed(fieldId, calcRefs, allowed, seen) {
+  const refs = calcRefs.get(fieldId);
+  if (refs === void 0) return allowed.has(fieldId);
+  if (seen.has(fieldId)) return true;
+  seen.add(fieldId);
+  for (const ref of refs) {
+    if (!jumpDepsAllowed(ref, calcRefs, allowed, seen)) return false;
+  }
+  return true;
+}
+function jumpRules(value, pageIds, sourceId, allowedFieldIds, calcRefs) {
   if (!Array.isArray(value)) return void 0;
   const rules = value.slice(0, 50).flatMap((item) => {
     if (!item || typeof item !== "object") return [];
@@ -1501,11 +1560,187 @@ function jumpRules(value, pageIds, sourceId, allowedFieldIds) {
     if (rawWhen !== void 0 && !Array.isArray(rawWhen)) return [];
     const when2 = conditions(rawWhen);
     if (Array.isArray(rawWhen) && rawWhen.length > 0 && when2 === void 0) return [];
-    if (when2 && when2.some((c) => !allowedFieldIds.has(c.fieldId))) return [];
+    if (when2 && when2.some((c) => !jumpDepsAllowed(c.fieldId, calcRefs, allowedFieldIds, /* @__PURE__ */ new Set())))
+      return [];
     return [{ when: when2 ?? [], to }];
   });
   return rules.length ? rules : void 0;
 }
+var CALC_OPERAND_KINDS = ["number", "rating", "linear_scale", "calculated"];
+function normalizeCalc(value, depth = 0) {
+  if (depth > 32) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const rec = value;
+  switch (rec.op) {
+    case "value": {
+      const fieldId = str(rec.fieldId, 128);
+      return fieldId ? { op: "value", fieldId } : null;
+    }
+    case "const": {
+      const n = finite(rec.value);
+      return n === void 0 ? null : { op: "const", value: n };
+    }
+    case "add":
+    case "mul":
+    case "min":
+    case "max": {
+      if (!Array.isArray(rec.args) || rec.args.length < 1 || rec.args.length > 50) return null;
+      const args = [];
+      for (const raw of rec.args) {
+        const arg = normalizeCalc(raw, depth + 1);
+        if (!arg) return null;
+        args.push(arg);
+      }
+      return { op: rec.op, args };
+    }
+    case "sub":
+    case "div": {
+      const left = normalizeCalc(rec.left, depth + 1);
+      const right = normalizeCalc(rec.right, depth + 1);
+      return left && right ? { op: rec.op, left, right } : null;
+    }
+    case "round": {
+      const arg = normalizeCalc(rec.arg, depth + 1);
+      if (!arg) return null;
+      return cleanObject({
+        op: "round",
+        arg,
+        decimals: finite(rec.decimals) === void 0 ? void 0 : int(rec.decimals, 0, 6, 0)
+      });
+    }
+    case "if": {
+      if (!Array.isArray(rec.when)) return null;
+      const when2 = conditions(rec.when) ?? [];
+      if (when2.length !== rec.when.length) return null;
+      const then = normalizeCalc(rec.then, depth + 1);
+      const els = normalizeCalc(rec.else, depth + 1);
+      return then && els ? { op: "if", when: when2, then, else: els } : null;
+    }
+    default:
+      return null;
+  }
+}
+function collectCalcRefs(expr, valueRefs, whenRefs) {
+  switch (expr.op) {
+    case "value":
+      valueRefs.add(expr.fieldId);
+      return;
+    case "const":
+      return;
+    case "add":
+    case "mul":
+    case "min":
+    case "max":
+      for (const arg of expr.args) collectCalcRefs(arg, valueRefs, whenRefs);
+      return;
+    case "sub":
+    case "div":
+      collectCalcRefs(expr.left, valueRefs, whenRefs);
+      collectCalcRefs(expr.right, valueRefs, whenRefs);
+      return;
+    case "round":
+      collectCalcRefs(expr.arg, valueRefs, whenRefs);
+      return;
+    case "if":
+      for (const cond of expr.when) whenRefs.add(cond.fieldId);
+      collectCalcRefs(expr.then, valueRefs, whenRefs);
+      collectCalcRefs(expr.else, valueRefs, whenRefs);
+      return;
+  }
+}
+function validateCalculatedFields(pages) {
+  const kinds = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const block of page.blocks) if (isField(block)) kinds.set(block.id, block.kind);
+  }
+  const deps = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const block of page.blocks) {
+      if (block.kind !== "calculated") continue;
+      const calc = normalizeCalc(block.calc);
+      if (!calc) {
+        return `Field ${block.id} has a malformed calc expression \u2014 build it from value/const/add/sub/mul/div/min/max/round/if nodes`;
+      }
+      block.calc = calc;
+      const valueRefs = /* @__PURE__ */ new Set();
+      const whenRefs = /* @__PURE__ */ new Set();
+      collectCalcRefs(calc, valueRefs, whenRefs);
+      for (const ref of valueRefs) {
+        const kind = kinds.get(ref);
+        if (kind === void 0) {
+          return `Calculated field ${block.id} references a missing field: ${ref} \u2014 remove the reference or restore that field`;
+        }
+        if (!CALC_OPERAND_KINDS.includes(kind)) {
+          return `Calculated field ${block.id} references non-numeric field ${ref} (${kind}) \u2014 calculations can read number, rating, linear_scale, and calculated fields only`;
+        }
+      }
+      deps.set(
+        block.id,
+        [...valueRefs, ...whenRefs].filter((ref) => kinds.get(ref) === "calculated")
+      );
+    }
+  }
+  const state = /* @__PURE__ */ new Map();
+  const visit = (id, path) => {
+    const mark = state.get(id);
+    if (mark === "done") return null;
+    if (mark === "visiting") {
+      const chain = [...path.slice(path.indexOf(id)), id].join(" \u2192 ");
+      return `Calculated field ${id} depends on its own result (${chain}) \u2014 break the cycle so the value can be computed`;
+    }
+    state.set(id, "visiting");
+    for (const dep of deps.get(id) ?? []) {
+      const error = visit(dep, [...path, id]);
+      if (error) return error;
+    }
+    state.set(id, "done");
+    return null;
+  };
+  for (const id of deps.keys()) {
+    const error = visit(id, []);
+    if (error) return error;
+  }
+  return null;
+}
+var MAX_CALC_FIELDS = 100;
+var MAX_CALC_TOTAL_NODES = 5e3;
+function countCalcNodes(expr) {
+  switch (expr.op) {
+    case "value":
+    case "const":
+      return 1;
+    case "add":
+    case "mul":
+    case "min":
+    case "max":
+      return 1 + expr.args.reduce((n, arg) => n + countCalcNodes(arg), 0);
+    case "sub":
+    case "div":
+      return 1 + countCalcNodes(expr.left) + countCalcNodes(expr.right);
+    case "round":
+      return 1 + countCalcNodes(expr.arg);
+    case "if":
+      return 1 + countCalcNodes(expr.then) + countCalcNodes(expr.else);
+  }
+}
+function calcComplexityError(pages) {
+  let calcFields = 0;
+  let totalNodes = 0;
+  for (const page of pages) {
+    for (const block of page.blocks) {
+      if (block.kind !== "calculated") continue;
+      calcFields += 1;
+      totalNodes += countCalcNodes(block.calc);
+    }
+  }
+  if (calcFields > MAX_CALC_FIELDS) {
+    return `Form has ${calcFields} calculated fields \u2014 the maximum is ${MAX_CALC_FIELDS}; remove some or consolidate them into fewer expressions`;
+  }
+  if (totalNodes > MAX_CALC_TOTAL_NODES) {
+    return `Calculated expressions total ${totalNodes} operations \u2014 the maximum is ${MAX_CALC_TOTAL_NODES} across the form; simplify or split up the calculations`;
+  }
+  return null;
+}
 function baseBlock(rec) {
   return {
     id: str(rec.id, 128),
@@ -1617,7 +1852,20 @@ function normalizeBlock(input) {
         maxLength: finite(rec.maxLength) === void 0 ? void 0 : int(rec.maxLength, 1, 2e4, 2e4)
       });
     case "number":
-      return cleanObject({ ...baseField(rec, kind), min: finite(rec.min), max: finite(rec.max) });
+      return cleanObject({
+        ...baseField(rec, kind),
+        min: finite(rec.min),
+        max: finite(rec.max),
+        // Display-only (decision 1 in the number-formatting contract) —
+        // mirrors the calculated field's decimals/prefix/suffix carry-through
+        // exactly, plus notation which calculated doesn't have.
+        decimals: finite(rec.decimals) === void 0 ? void 0 : int(rec.decimals, 0, 6, 0),
+        prefix: optionalAffix(rec.prefix, 100),
+        suffix: optionalAffix(rec.suffix, 100),
+        // The only supported values; anything else drops silently rather than
+        // erroring (an old/garbage value is just "no grouping").
+        notation: rec.notation === "grouped" ? "grouped" : rec.notation === "grouped-comma" ? "grouped-comma" : rec.notation === "grouped-dot" ? "grouped-dot" : void 0
+      });
     case "select":
     case "multi_select":
     case "dropdown": {
@@ -1681,6 +1929,21 @@ function normalizeBlock(input) {
         paramName: optionalStr(rec.paramName, 128),
         defaultValue: optionalStr(rec.defaultValue, 1e3)
       });
+    case "calculated":
+      return cleanObject({
+        ...baseField(rec, kind),
+        // A derived value isn't answerable, so it can't be required (the
+        // hidden-field precedent) — a required one could never be satisfied.
+        required: false,
+        // Kept raw here on purpose: the calc AST is normalized and structurally
+        // validated in normalizeFormSchema once the full field universe is
+        // known (missing refs, operand kinds, cycles are HARD errors there — a
+        // calculated field must never be silently dropped or degraded).
+        calc: rec.calc,
+        decimals: finite(rec.decimals) === void 0 ? void 0 : int(rec.decimals, 0, 6, 0),
+        prefix: optionalAffix(rec.prefix, 100),
+        suffix: optionalAffix(rec.suffix, 100)
+      });
     case "file_upload":
       return cleanObject({
         ...baseField(rec, kind),
@@ -1719,6 +1982,22 @@ function normalizeFormSchema(input) {
     return { id: str(page.id, 128), title: optionalStr(page.title, 500), blocks, next: page.next };
   });
   const targetIds = new Set(rebuilt.map((p) => p.id));
+  const calcRefs = /* @__PURE__ */ new Map();
+  for (const page of rebuilt) {
+    for (const block of page.blocks) {
+      if (block.kind !== "calculated") continue;
+      const refs = /* @__PURE__ */ new Set();
+      const calc = normalizeCalc(block.calc);
+      if (calc) {
+        const valueRefs = /* @__PURE__ */ new Set();
+        const whenRefs = /* @__PURE__ */ new Set();
+        collectCalcRefs(calc, valueRefs, whenRefs);
+        for (const ref of valueRefs) refs.add(ref);
+        for (const ref of whenRefs) refs.add(ref);
+      }
+      calcRefs.set(block.id, refs);
+    }
+  }
   const priorFieldIds = /* @__PURE__ */ new Set();
   const pages = rebuilt.map((page) => {
     for (const block of page.blocks) {
@@ -1728,7 +2007,7 @@ function normalizeFormSchema(input) {
       id: page.id,
       title: page.title,
       blocks: page.blocks,
-      next: jumpRules(page.next, targetIds, page.id, new Set(priorFieldIds))
+      next: jumpRules(page.next, targetIds, page.id, new Set(priorFieldIds), calcRefs)
     });
   });
   const pageIds = /* @__PURE__ */ new Set();
@@ -1763,6 +2042,10 @@ function normalizeFormSchema(input) {
       }
     }
   }
+  const calcError = validateCalculatedFields(pages);
+  if (calcError) return { ok: false, error: calcError };
+  const calcComplexity = calcComplexityError(pages);
+  if (calcComplexity) return { ok: false, error: calcComplexity };
   if (pages.every((page) => page.blocks.length === 0)) {
     return { ok: false, error: "Schema must contain at least one valid block" };
   }
@@ -1788,6 +2071,7 @@ var MASK = 256 - 256 % ALPHABET.length;
 var S3_PART_TIMEOUT_MS = 5 * 6e4;
 var UPLOAD_CONTROL_TIMEOUT_MS = 10 * 6e4;
 var CLIENT_HEADER = { "X-Fillo-Client": `@usefillo/core@${FILLO_SDK_VERSION}` };
+var DARK_LUMINANCE_THRESHOLD = Math.sqrt(1.05 * 0.05) - 0.05;
 var FilloJsxError = class extends Error {
   constructor(code, message) {
     super(`[fillo] ${message} \u2014 https://fillo.so/docs/troubleshooting#jsx-${code.toLowerCase()}`);
@@ -1818,7 +2102,7 @@ var JSX_BLOCK_SPECS = [
   field("Email", "email", ["maxLength"]),
   field("Url", "url", ["maxLength"]),
   field("Phone", "phone", ["defaultCountry"]),
-  field("Number", "number", ["min", "max"]),
+  field("Number", "number", ["min", "max", "decimals", "prefix", "suffix", "notation"]),
   field("Select", "select", CHOICE_EXTRA, { optionChildren: true }),
   field("MultiSelect", "multi_select", CHOICE_EXTRA, { optionChildren: true }),
   field("Dropdown", "dropdown", CHOICE_EXTRA, { optionChildren: true }),
@@ -1831,6 +2115,7 @@ var JSX_BLOCK_SPECS = [
   field("Date", "date", []),
   field("FileUpload", "file_upload", ["maxFiles", "maxFileSizeMb", "accept"]),
   field("Hidden", "hidden", ["paramName", "defaultValue"]),
+  field("Calculated", "calculated", ["calc", "decimals", "prefix", "suffix"]),
   field("Custom", "custom", ["component", "config"]),
   content("Heading", "heading", true),
   content("Paragraph", "paragraph", true),
@@ -1927,6 +2212,7 @@ function openBrowser(url) {
   } catch {
     return;
   }
+  if (process.env.CI === "true") return;
   try {
     if (process.platform === "win32") {
       const child = spawn("cmd", ["/c", "start", "", safeUrl], { stdio: "ignore", detached: true });
@@ -1963,7 +2249,7 @@ async function readJson(res) {
     die(`Unexpected non-JSON response from ${API} (${res.status}).`);
   }
 }
-async function login(flags) {
+async function login(flags, options2 = {}) {
   const apiBase = flagString(flags, "api")?.replace(/\/$/, "") ?? API;
   const run = flagString(flags, "run");
   const progressToken = flagString(flags, "token");
@@ -2012,7 +2298,9 @@ Login failed (${r.status}).`);
       console.log("\n");
       await whoami(apiBase);
       console.log(
-        run ? `
+        options2.continueToAgentRun ? `
+  ${dim("Workspace approved. Connecting this setup...")}
+` : run ? `
   ${dim("Return to the Fillo setup prompt and run its next command.")}
 ` : `
   ${dim("Now run:")} fillo push form.json
@@ -2021,7 +2309,8 @@ Login failed (${r.status}).`);
       return;
     }
     if (body.error === "slow_down") interval += 2e3;
-    else if (body.error && body.error !== "authorization_pending") die(`
+    else if (body.error && body.error !== "authorization_pending")
+      die(`
 Login failed: ${body.error}`);
   }
   die("\nLogin timed out \u2014 run `fillo login` again.");
@@ -2043,10 +2332,174 @@ async function list() {
   if (!forms.length) return console.log("  No forms yet.");
   for (const f of forms) {
     console.log(
-      `  ${f.status === "published" ? "\x1B[32m\u25CF\x1B[0m" : "\u25CB"} ${terminalText(f.name)}  ${dim(f.id)}`
+      `  ${f.status === "published" ? "\x1B[32m\u25CF\x1B[0m" : "\u25CB"} ${terminalText(f.name)}  ${dim(f.id)}  ${dim(f.url)}`
     );
   }
 }
+async function status(handle) {
+  if (!handle) die("Usage: fillo status <formId|handle>");
+  const res = await api(`/cli/forms/${encodeURIComponent(handle)}`, { token: requireToken() });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (res.status === 404) {
+    try {
+      JSON.parse(await res.text());
+    } catch {
+      die(
+        "This Fillo server does not support `fillo status` yet. Update the deployment, or check the form in the dashboard."
+      );
+    }
+    die(`No form matches "${handle}" in this workspace. Run \`fillo list\` to see its forms.`);
+  }
+  const body = await readJson(res);
+  if (!res.ok || !body.form) die(body.error ?? `status failed (${res.status}).`);
+  const form = body.form;
+  console.log(
+    `  ${form.status === "published" ? "\x1B[32m\u25CF\x1B[0m" : "\u25CB"} ${terminalText(form.name)}  ${dim(form.id)}`
+  );
+  console.log(`  Status: ${bold(form.staged ? "staged" : form.status)}`);
+  if (form.status === "published") console.log(`  Live at ${terminalText(form.url)}`);
+  else console.log(`  ${dim(`Publishes to ${form.url}`)}`);
+  if (form.staged) {
+    console.log(`  ${dim("Staged changes are waiting for review in the Fillo dashboard.")}`);
+  }
+  if (form.warning) {
+    const pending = form.status !== "published" || form.staged === true;
+    console.log(`  ${dim(pending ? `Before publishing: ${form.warning}` : form.warning)}`);
+  }
+  if (form.warningUrl) console.log(`  Storage settings: ${terminalText(form.warningUrl)}`);
+}
+async function publish(handle, flags) {
+  if (!handle) die("Usage: fillo publish <formId|handle> [--allow-breaking]");
+  const res = await api(`/cli/forms/${encodeURIComponent(handle)}/publish`, {
+    method: "POST",
+    token: requireToken(),
+    body: JSON.stringify(flags["allow-breaking"] === true ? { allowBreaking: true } : {})
+  });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (res.status === 404) {
+    try {
+      JSON.parse(await res.text());
+    } catch {
+      die(
+        "This Fillo server does not support `fillo publish` yet. Update the deployment, or publish the form from the dashboard."
+      );
+    }
+    die(`No form matches "${handle}" in this workspace. Run \`fillo list\` to see its forms.`);
+  }
+  const body = await readJson(res);
+  if (res.status === 409 && body.code === "breaking_changes") {
+    const fields = Array.isArray(body.breakingFields) ? body.breakingFields.filter((f) => typeof f === "string") : [];
+    console.error(
+      "\x1B[31m\u2717\x1B[0m Not published \u2014 the staged changes remove or re-type fields that existing responses answered."
+    );
+    if (fields.length) console.error(`  Fields: ${terminalText(fields.join(", "))}`);
+    console.error(
+      `  ${dim("Recorded answers are kept, but the live form, grid, and exports stop showing these fields.")}`
+    );
+    console.error("  Re-run with --allow-breaking to publish anyway.");
+    process.exit(1);
+  }
+  if (res.status === 409 && typeof body.warningUrl === "string" && body.warningUrl) {
+    console.error(
+      `\x1B[31m\u2717\x1B[0m ${terminalText(body.error ?? `publish failed (${res.status}).`)}`
+    );
+    console.error(`  Storage settings: ${terminalText(body.warningUrl)}`);
+    process.exit(1);
+  }
+  if (!res.ok || !body.form) die(body.error ?? `publish failed (${res.status}).`);
+  const form = body.form;
+  if (body.changed === false) {
+    console.log(
+      `
+  \x1B[32m\u2713\x1B[0m ${bold(terminalText(form.name))} is already live \u2014 nothing staged to publish.`
+    );
+  } else {
+    console.log(`
+  \x1B[32m\u2713\x1B[0m Published ${bold(terminalText(form.name))}  ${dim(form.id)}`);
+  }
+  console.log(`  Live at ${terminalText(form.url)}
+`);
+}
+async function loadResponseData(file) {
+  let value;
+  if (file === "-") {
+    try {
+      const chunks = [];
+      let bytes = 0;
+      for await (const chunk of process.stdin) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        if (bytes > MAX_STDIN_SCHEMA_BYTES) {
+          die("The response data on stdin is too large (maximum 1 MB).");
+        }
+        chunks.push(buffer);
+      }
+      const input = Buffer.concat(chunks).toString("utf8");
+      if (!input.trim()) {
+        die("stdin is empty - pipe one JSON answer object to `fillo test-response <form> -`.");
+      }
+      value = JSON.parse(input);
+    } catch (error) {
+      die(`Couldn't read response data from stdin: ${error.message}`);
+    }
+  } else {
+    const abs = isAbsolute(file) ? file : resolve(process.cwd(), file);
+    if (!abs.endsWith(".json")) {
+      die("Test response data must be a .json file (or - for JSON on stdin).");
+    }
+    try {
+      value = JSON.parse(readFileSync(abs, "utf8"));
+    } catch (error) {
+      die(`Couldn't read ${file}: ${error.message}`);
+    }
+  }
+  if (!isRecord(value)) {
+    die("Test response data must be one JSON object keyed by field id.");
+  }
+  return value;
+}
+async function testResponse(handle, file) {
+  if (!handle || !file) {
+    die("Usage: fillo test-response <formId|handle> <answers.json|->");
+  }
+  const token = requireToken();
+  const data = await loadResponseData(file);
+  const res = await api(`/cli/forms/${encodeURIComponent(handle)}/test-response`, {
+    method: "POST",
+    token,
+    body: JSON.stringify({ data })
+  });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (res.status === 404) {
+    try {
+      JSON.parse(await res.text());
+    } catch {
+      die(
+        "This Fillo server does not support `fillo test-response` yet. Update the deployment, then retry."
+      );
+    }
+    die(`No form matches "${handle}" in this workspace. Run \`fillo list\` to see its forms.`);
+  }
+  const body = await readJson(res);
+  if (res.status === 422 && body.errors && typeof body.errors === "object") {
+    console.error("\x1B[31m\u2717\x1B[0m Test response failed server validation.");
+    for (const [field2, message] of Object.entries(body.errors)) {
+      console.error(`  ${terminalText(field2)}: ${terminalText(message)}`);
+    }
+    process.exit(1);
+  }
+  if (!res.ok || !body.id || body.preview !== true) {
+    die(body.error ?? `test response failed (${res.status}).`);
+  }
+  console.log(
+    `
+  \x1B[32m\u2713\x1B[0m Test response passed the ${bold(body.schema ?? "current")} schema  ${dim(body.id)}`
+  );
+  console.log(
+    `  ${dim("Preview only \u2014 excluded from responses, limits, delivery, and analytics; auto-deletes after 7 days.")}
+`
+  );
+}
 async function loadSchema(file, allowCode) {
   if (file === "-") {
     try {
@@ -2117,6 +2570,8 @@ function printPushed(formId, url, updated, draft = false) {
   if (draft) console.log(`  ${dim("Review and publish it from the Fillo dashboard.")}`);
   else if (url) console.log(`  Live at ${terminalText(url)}`);
   console.log(`  Embed:  <FilloForm formId="${terminalText(formId)}" />
+`);
+  console.log(`  Verify: [data-fillo-form-id="${terminalText(formId)}"] on the actual app route
 `);
 }
 function syncError(response, body, credential) {
@@ -2160,7 +2615,10 @@ function printSynced(body, requestedStage) {
     console.log(`  Live at ${terminalText(`${API}/f/${body.slug}`)}`);
   }
   if (body.warning) console.log(`  ${dim(`Before publishing: ${body.warning}`)}`);
+  if (body.warningUrl) console.log(`  Storage settings: ${terminalText(body.warningUrl)}`);
   console.log(`  Embed:  <FilloForm formId="${terminalText(formId)}" />
+`);
+  console.log(`  Verify: [data-fillo-form-id="${terminalText(formId)}"] on the actual app route
 `);
 }
 async function pushWithSync(items, credential, requestedStage) {
@@ -2206,7 +2664,9 @@ async function push(file, flags) {
     );
   }
   if (!syncToken && !accountToken && stage) {
-    die(`To stage changes, run \`fillo login\` or set ${SYNC_TOKEN_ENV} from Settings > Developers.`);
+    die(
+      `To stage changes, run \`fillo login\` or set ${SYNC_TOKEN_ENV} from Settings > Developers.`
+    );
   }
   const handle = typeof flags.handle === "string" ? flags.handle : void 0;
   const items = toPushItems(await loadSchema(file, flags["allow-code"] === true), handle);
@@ -2249,7 +2709,16 @@ async function push(file, flags) {
         })
       });
       const body = await readJson(res);
-      if (!res.ok || !body.formId) die(body.error ?? `push failed (${res.status}).`);
+      if (!res.ok || !body.formId) {
+        if (res.status === 409 && typeof body.warningUrl === "string" && body.warningUrl) {
+          console.error(
+            `\x1B[31m\u2717\x1B[0m ${terminalText(body.error ?? `push failed (${res.status}).`)}`
+          );
+          console.error(`  Storage settings: ${terminalText(body.warningUrl)}`);
+          process.exit(1);
+        }
+        die(body.error ?? `push failed (${res.status}).`);
+      }
       printPushed(body.formId, body.url, !!body.updated);
     }
     return;
@@ -2263,7 +2732,9 @@ async function push(file, flags) {
 async function init(flags) {
   const email3 = typeof flags.email === "string" ? flags.email.trim() : "";
   if (!email3) {
-    die("Usage: fillo init --email you@company.com (or run `fillo login` for an existing account).");
+    die(
+      "Usage: fillo init --email you@company.com (or run `fillo login` for an existing account)."
+    );
   }
   const res = await api("/workspaces/provision", {
     method: "POST",
@@ -2273,13 +2744,17 @@ async function init(flags) {
   if (!res.ok || !body.key) die(body.error ?? `init failed (${res.status}).`);
   const { claimUrl: _legacyWorkspaceLink, ...current } = readConfig();
   writeConfig({ ...current, pk: body.key });
-  console.log(`
-  \x1B[32m\u2713\x1B[0m Workspace ready. A workspace link was sent to ${bold(terminalText(email3))}.`);
+  console.log(
+    `
+  \x1B[32m\u2713\x1B[0m Workspace ready. A workspace link was sent to ${bold(terminalText(email3))}.`
+  );
   if (body.limits) {
     const expiry = Date.parse(body.limits.expiresAt);
     if (Number.isFinite(expiry)) {
       const days = Math.max(1, Math.round((expiry - Date.now()) / 864e5));
-      console.log(`  ${dim(`Preview: up to ${body.limits.responses} responses for ~${days} days.`)}`);
+      console.log(
+        `  ${dim(`Preview: up to ${body.limits.responses} responses for ~${days} days.`)}`
+      );
     }
   }
   console.log(`
@@ -2288,6 +2763,18 @@ async function init(flags) {
 `);
 }
 var AGENT_ACTIONS = ["claim_required", "storage_required", "publish_required"];
+var AGENT_EVENT_STATUSES = [
+  "created",
+  "connected",
+  "asking",
+  "planning",
+  "installing",
+  "editing",
+  "checking",
+  "needs_action",
+  "done",
+  "error"
+];
 var FORM_STATUSES = ["draft", "published"];
 function enumFlag(flags, key, allowed) {
   const value = flags[key];
@@ -2311,46 +2798,40 @@ async function agent(subcommand, flags) {
     return agentHelp();
   }
   if (!run || !token) {
-    die("Usage: fillo agent <connect|event> --run <id> --token <token> [--api <url>]");
+    die("Usage: fillo agent <bootstrap|connect|event> --run <id> --token <token> [--api <url>]");
   }
   if (flags.account !== void 0 && flags.account !== true) {
     die("--account does not take a value.");
   }
-  if (subcommand === "connect") {
-    const account = flags.account === true ? await attachAgentAccount(apiBase, run, token) : void 0;
-    await postAgentEvent(apiBase, run, token, {
-      status: "connected",
-      message: "Agent connected. Reading the app now."
-    });
-    console.log(`  \x1B[32m\u2713\x1B[0m Live progress connected.`);
-    if (account) {
-      console.log(`  \x1B[32m\u2713\x1B[0m ${bold(account.workspace)}`);
-      console.log(`  ${dim("Publishable key:")} ${account.publishableKey}`);
+  if (subcommand === "bootstrap") {
+    installSkill(flags);
+    if (flags.account === true) {
+      await login(flags, { continueToAgentRun: true });
     }
-    console.log(`  ${dim("Report next steps with:")}`);
-    console.log(
-      `  fillo agent event --api ${terminalText(apiBase)} --run ${terminalText(run)} --token <same-token> --status editing --message "Editing the form screen"`
-    );
-    return;
+    return connectAgentRun(apiBase, run, token, flags.account === true);
+  }
+  if (subcommand === "connect") {
+    return connectAgentRun(apiBase, run, token, flags.account === true);
   }
   if (flags.account === true) {
-    die("--account can only be used with `fillo agent connect`.");
+    die("--account can only be used with `fillo agent bootstrap` or `fillo agent connect`.");
   }
   if (subcommand === "event") {
-    const status = flagString(flags, "status");
+    const status2 = enumFlag(flags, "status", AGENT_EVENT_STATUSES);
     const message = flagString(flags, "message");
-    if (!status) die("Usage: fillo agent event --status <status> --message <short update>");
+    if (!status2)
+      die('Usage: fillo agent event --status <status> --message "<what the human does next>"');
     const action = enumFlag(flags, "action", AGENT_ACTIONS);
     const formStatus = enumFlag(flags, "form-status", FORM_STATUSES);
     const formId = optionalStringFlag(flags, "form-id");
-    if ((status === "done" || status === "needs_action") && !formId) {
-      die(`--form-id is required when --status is ${status}.`);
+    if ((status2 === "done" || status2 === "needs_action") && !formId) {
+      die(`--form-id is required when --status is ${status2}.`);
     }
-    if (status === "needs_action" && !action) {
+    if (status2 === "needs_action" && !action) {
       die("--action is required when --status is needs_action.");
     }
     await postAgentEvent(apiBase, run, token, {
-      status,
+      status: status2,
       message,
       appUrl: flagString(flags, "app-url"),
       action,
@@ -2363,6 +2844,25 @@ async function agent(subcommand, flags) {
   }
   die(`Unknown agent command: ${subcommand}`);
 }
+async function connectAgentRun(apiBase, run, token, attachAccount) {
+  const account = attachAccount ? await attachAgentAccount(apiBase, run, token) : void 0;
+  await postAgentEvent(apiBase, run, token, {
+    status: "connected",
+    message: "Agent connected. Reading the app now."
+  });
+  console.log(`  \x1B[32m\u2713\x1B[0m Live progress connected.`);
+  if (account) {
+    console.log(`  \x1B[32m\u2713\x1B[0m ${bold(account.workspace)}`);
+    console.log(`  ${dim("Publishable key:")} ${account.publishableKey}`);
+  }
+  console.log(`  ${dim("Report next steps with:")}`);
+  console.log(
+    `  fillo agent event --api ${terminalText(apiBase)} --run ${terminalText(run)} --token <same-token> --status editing --message "Editing the form screen"`
+  );
+  console.log(
+    `  ${dim("For needs_action or done, lead --message with what the human does next \u2014 max 180 chars, longer is cut off.")}`
+  );
+}
 var SKILL_AGENT_DIRECTORIES = {
   shared: ".agents/skills",
   universal: ".agents/skills",
@@ -2446,9 +2946,7 @@ function pathEntryExists(path) {
 var MANAGED_SKILL_MARKER = ".fillo-managed.json";
 function isCliManagedFilloSkill(target) {
   try {
-    const marker = JSON.parse(
-      readFileSync(join(target, MANAGED_SKILL_MARKER), "utf8")
-    );
+    const marker = JSON.parse(readFileSync(join(target, MANAGED_SKILL_MARKER), "utf8"));
     return marker.managedBy === "@usefillo/cli" && marker.skill === "build-with-fillo" && marker.format === 1 && marker.allowAutomaticUpdates === true;
   } catch {
     return false;
@@ -2503,19 +3001,14 @@ function installSkill(flags) {
   if (!existsSync(BUNDLED_SKILL_DIR)) {
     die("This CLI package is missing its bundled Fillo skill. Reinstall @usefillo/cli@latest.");
   }
-  const destinations = Array.from(
-    new Set(skillDirectories)
-  ).map((skillDirectory) => {
+  const destinations = Array.from(new Set(skillDirectories)).map((skillDirectory) => {
     const skillsRoot = resolve(scopeRoot, skillDirectory);
     const target = join(skillsRoot, "build-with-fillo");
     const relativeSkillsRoot = relative(scopeRoot, skillsRoot);
     if (relativeSkillsRoot === ".." || relativeSkillsRoot.startsWith(`..${sep}`) || isAbsolute(relativeSkillsRoot)) {
       die("The skill destination must stay inside the selected project or home scope.");
     }
-    const destinationParts = [
-      ...relativeSkillsRoot.split(sep).filter(Boolean),
-      "build-with-fillo"
-    ];
+    const destinationParts = [...relativeSkillsRoot.split(sep).filter(Boolean), "build-with-fillo"];
     assertSafeSkillDestination(scopeRoot, destinationParts);
     const targetExists = pathEntryExists(target);
     const current = targetExists && sameSkillBundle(BUNDLED_SKILL_DIR, target);
@@ -2536,10 +3029,7 @@ function installSkill(flags) {
     if (destination.current) continue;
     mkdirSync(destination.skillsRoot, { recursive: true });
     assertSafeSkillDestination(scopeRoot, destination.destinationParts.slice(0, 2));
-    const staging = join(
-      destination.skillsRoot,
-      `.build-with-fillo.install-${randomUUID()}`
-    );
+    const staging = join(destination.skillsRoot, `.build-with-fillo.install-${randomUUID()}`);
     try {
       cpSync(BUNDLED_SKILL_DIR, staging, { recursive: true, errorOnExist: true });
       assertSafeSkillDestination(scopeRoot, destination.destinationParts);
@@ -2585,18 +3075,15 @@ async function postAgentEvent(apiBase, run, token, body) {
 }
 async function attachAgentAccount(apiBase, run, progressToken) {
   const accountToken = requireTokenFor(apiBase);
-  const res = await fetch(
-    `${apiBase}/api/v1/agent-runs/${encodeURIComponent(run)}/account`,
-    {
-      method: "POST",
-      redirect: "error",
-      headers: {
-        Authorization: `Bearer ${accountToken}`,
-        "X-Fillo-Agent-Run-Token": progressToken
-      },
-      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-    }
-  );
+  const res = await fetch(`${apiBase}/api/v1/agent-runs/${encodeURIComponent(run)}/account`, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      Authorization: `Bearer ${accountToken}`,
+      "X-Fillo-Agent-Run-Token": progressToken
+    },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
   const payload = await res.json().catch(() => ({}));
   if (!res.ok) {
     const hint = res.status === 401 ? " Run `fillo login` and try again." : "";
@@ -2612,15 +3099,22 @@ function agentHelp() {
   ${bold("fillo agent")} \u2014 report live progress back to a Fillo prompt modal
 
   ${bold("Commands")}
+    agent bootstrap     Install the skill and connect this coding-agent run
+                       ${dim("--account   approve and attach an existing workspace in the browser")}
     agent connect       Connect a coding-agent run to the open browser modal
                        ${dim("--account   attach the workspace from `fillo login`")}
     agent event         Send a short progress update
-                       ${dim("--status <created|connected|asking|planning|installing|editing|checking|needs_action|done|error>")}
-                       ${dim('--message "Short update"')}
+                       ${dim(`--status <${AGENT_EVENT_STATUSES.join("|")}>`)}
+                       ${dim('--message "What the human does next" (max 180 chars)')}
                        ${dim("--form-id <id> --form-status <draft|published> --form-name <name>")}
                        ${dim("--action <claim_required|storage_required|publish_required>")}
                        ${dim("--app-url <localhost-url>")}
                        ${dim("--run <id> --token <token> --api <url>")}
+
+  ${dim("For --status needs_action or done, lead the message with what the human does")}
+  ${dim('next, in one or two sentences, plus the form URL or form id \u2014 e.g. "Connect')}
+  ${dim('storage in Fillo, publish the form, then submit one test response".')}
+  ${dim("Max 180 characters \u2014 longer is cut off. Never list changed files in the message.")}
 `);
 }
 function skillHelp() {
@@ -2661,8 +3155,14 @@ function help() {
                        ${dim("--stage          stage beside the live form for dashboard review")}
                        ${dim("--draft          alias with a handle; legacy one-off draft without")}
                        ${dim("--allow-code     allow a .mjs/.js schema (executes the file)")}
-    list               List the workspace's forms
-    agent <cmd>        Report live progress to a Fillo prompt modal
+    list               List the workspace's forms and their live URLs
+    status <form>      Show one form's status, live URL, and publish blockers
+                       ${dim("<form> is a form id or handle")}
+    publish <form>     Publish staged changes (or a draft form) \u2014 prints the live URL
+                       ${dim("--allow-breaking  confirm removing/re-typing fields responses answered")}
+    test-response <form> <file|->
+                       Validate answers against staged changes without real delivery
+    agent <cmd>        Prepare an agent run and report live progress
     skill install      Install the Build with Fillo Agent Skill
 
   ${dim(`API: ${API}  \xB7  set FILLO_API to override`)}
@@ -2671,6 +3171,7 @@ function help() {
 }
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "account",
+  "allow-breaking",
   "allow-code",
   "draft",
   "stage",
@@ -2691,6 +3192,9 @@ var FLAGS_BY_COMMAND = {
   push: ["handle", "stage", "draft", "allow-code"],
   list: [],
   ls: [],
+  status: [],
+  publish: ["allow-breaking"],
+  "test-response": [],
   agent: [
     "run",
     "token",
@@ -2709,10 +3213,7 @@ var FLAGS_BY_COMMAND = {
   version: []
 };
 function validateFlags(command, flags) {
-  const allowed = /* @__PURE__ */ new Set([
-    ...GLOBAL_FLAGS,
-    ...command ? FLAGS_BY_COMMAND[command] ?? [] : []
-  ]);
+  const allowed = /* @__PURE__ */ new Set([...GLOBAL_FLAGS, ...command ? FLAGS_BY_COMMAND[command] ?? [] : []]);
   for (const [key, value] of Object.entries(flags)) {
     if (!allowed.has(key)) die(`Unknown flag for ${command ?? "fillo"}: --${key}`);
     if (BOOLEAN_FLAGS.has(key)) {
@@ -2790,6 +3291,12 @@ async function main() {
     case "list":
     case "ls":
       return list();
+    case "status":
+      return status(positional[0]);
+    case "publish":
+      return publish(positional[0], flags);
+    case "test-response":
+      return testResponse(positional[0], positional[1]);
     case "agent":
       return agent(positional[0], flags);
     case "skill":