@cosmosos/mcp-ephemeris 0.1.0 → 0.2.0

package/dist/index.js

@@ -242,8 +242,8 @@ function helioToGeoLonLat(p, e) {
     lat: Math.atan2(zg, Math.hypot(xg, yg)) * D
   };
 }
-function isRetrograde(key, JD) {
-  if (!(key in PE)) return false;
+function angularSpeed(key, JD) {
+  if (!(key in PE)) return void 0;
   const T1 = (JD - 0.5 - 2451545) / 36525;
   const T2 = (JD + 0.5 - 2451545) / 36525;
   const e1 = helioPos3D("earth", T1), e2 = helioPos3D("earth", T2);
@@ -253,7 +253,11 @@ function isRetrograde(key, JD) {
   let diff = g2 - g1;
   if (diff > 180) diff -= 360;
   if (diff < -180) diff += 360;
-  return diff < 0;
+  return diff;
+}
+function isRetrograde(key, JD) {
+  const v = angularSpeed(key, JD);
+  return v !== void 0 && v < 0;
 }
 
 // ../ephemeris/src/solar-lunar.ts
@@ -406,8 +410,18 @@ function placidusHouses(RAMC, lat, ob) {
   c[5] = n360(c[11] + 180);
   c[7] = n360(c[1] + 180);
   c[8] = n360(c[2] + 180);
+  if (!cuspsInZodiacalOrder(c)) return equalHouses(asc);
   return c;
 }
+function cuspsInZodiacalOrder(c) {
+  let sum = 0;
+  for (let i = 0; i < 12; i++) {
+    const arc = n360(c[(i + 1) % 12] - c[i]);
+    if (arc <= 0 || arc >= 180) return false;
+    sum += arc;
+  }
+  return Math.abs(sum - 360) < 1e-6;
+}
 function equalHouses(asc) {
   return Array.from({ length: 12 }, (_, i) => n360(asc + i * 30));
 }
@@ -415,8 +429,32 @@ function wholeSignHouses(asc) {
   const base = Math.floor(asc / 30) * 30;
   return Array.from({ length: 12 }, (_, i) => n360(base + i * 30));
 }
-function kochHouses(RAMC, lat, ob) {
-  return placidusHouses(RAMC, lat, ob);
+var _houseSubstitutionWarned = /* @__PURE__ */ new Set();
+function warnHouseSubstitutionOnce(system) {
+  if (_houseSubstitutionWarned.has(system)) return;
+  _houseSubstitutionWarned.add(system);
+  console.warn(
+    `[ephemeris/houses] Syst\xE8me "${system}" non disponible sur le moteur de secours AstraCore \u2014 repli honn\xEAte sur Placidus (system renvoy\xE9 = "placidus"). Le vrai calcul n\xE9cessite Swiss Ephemeris.`
+  );
+}
+function porphyryHouses(asc, mc) {
+  const ic = n360(mc + 180);
+  const dsc = n360(asc + 180);
+  const c = new Array(12);
+  c[0] = asc;
+  c[3] = ic;
+  c[6] = dsc;
+  c[9] = mc;
+  const tris = (from, to, i1, i2) => {
+    const arc = n360(to - from);
+    c[i1] = n360(from + arc / 3);
+    c[i2] = n360(from + 2 * arc / 3);
+  };
+  tris(asc, ic, 1, 2);
+  tris(ic, dsc, 4, 5);
+  tris(dsc, mc, 7, 8);
+  tris(mc, asc, 10, 11);
+  return c;
 }
 function calculateHousesByCoords(system, JD, lat, lng) {
   const T = (JD - 2451545) / 36525;
@@ -425,6 +463,7 @@ function calculateHousesByCoords(system, JD, lat, lng) {
   const asc = calcASC(RA, lat, ob);
   const mc = calcMC(RA, ob);
   let cusps;
+  let effectiveSystem = system;
   switch (system) {
     case "equal":
       cusps = equalHouses(asc);
@@ -432,14 +471,24 @@ function calculateHousesByCoords(system, JD, lat, lng) {
     case "whole_sign":
       cusps = wholeSignHouses(asc);
       break;
+    // HOUSE-SYSTEMS-EXTEND-V1 : Porphyry = trisection pure des quadrants
+    // ASC→IC→DSC→MC. Exact sans trigonométrie sphérique, donc calculable
+    // aussi en AstraCore (pas de substitution).
+    case "porphyry":
+      cusps = porphyryHouses(asc, mc);
+      break;
     case "koch":
-      cusps = kochHouses(RA, lat, ob);
+    case "regiomontanus":
+    case "campanus":
+      warnHouseSubstitutionOnce(system);
+      cusps = placidusHouses(RA, lat, ob);
+      effectiveSystem = "placidus";
       break;
     case "placidus":
     default:
       cusps = placidusHouses(RA, lat, ob);
   }
-  return { cusps, asc, mc, vertex: null, system };
+  return { cusps, asc, mc, vertex: null, system: effectiveSystem };
 }
 function houseOfLongitude(lon, cusps) {
   for (let i = 0; i < 12; i++) {
@@ -531,41 +580,112 @@ function computeHermeticLots(asc, planets, isNight, fortune) {
 }
 
 // ../ephemeris/src/astro-engine.ts
+function deltaTSeconds(JD) {
+  const year = 2e3 + (JD - 2451545) / 365.25;
+  const longTerm = (y) => {
+    const u = (y - 1820) / 100;
+    return -20 + 32 * u * u;
+  };
+  if (year < 1800 || year >= 2150) return longTerm(year);
+  let t;
+  if (year < 1860) {
+    t = year - 1800;
+    return 13.72 - 0.332447 * t + 68612e-7 * t ** 2 + 41116e-7 * t ** 3 - 37436e-8 * t ** 4 + 121272e-10 * t ** 5 - 1699e-10 * t ** 6 + 875e-12 * t ** 7;
+  }
+  if (year < 1900) {
+    t = year - 1860;
+    return 7.62 + 0.5737 * t - 0.251754 * t ** 2 + 0.01680668 * t ** 3 - 4473624e-10 * t ** 4 + t ** 5 / 233174;
+  }
+  if (year < 1920) {
+    t = year - 1900;
+    return -2.79 + 1.494119 * t - 0.0598939 * t ** 2 + 61966e-7 * t ** 3 - 197e-6 * t ** 4;
+  }
+  if (year < 1941) {
+    t = year - 1920;
+    return 21.2 + 0.84493 * t - 0.0761 * t ** 2 + 20936e-7 * t ** 3;
+  }
+  if (year < 1961) {
+    t = year - 1950;
+    return 29.07 + 0.407 * t - t ** 2 / 233 + t ** 3 / 2547;
+  }
+  if (year < 1986) {
+    t = year - 1975;
+    return 45.45 + 1.067 * t - t ** 2 / 260 - t ** 3 / 718;
+  }
+  if (year < 2005) {
+    t = year - 2e3;
+    return 63.86 + 0.3345 * t - 0.060374 * t ** 2 + 17275e-7 * t ** 3 + 651814e-9 * t ** 4 + 2373599e-11 * t ** 5;
+  }
+  if (year < 2050) {
+    t = year - 2e3;
+    return 62.92 + 0.32217 * t + 5589e-6 * t ** 2;
+  }
+  return -20 + 32 * ((year - 1820) / 100) ** 2 - 0.5628 * (2150 - year);
+}
+function ttCenturiesFromUT(jdUT) {
+  return (jdUT + deltaTSeconds(jdUT) / 86400 - 2451545) / 36525;
+}
 function allPositions(JD) {
-  const T = (JD - 2451545) / 36525;
+  const T = ttCenturiesFromUT(JD);
   const pos = {};
+  const HALF_DAY_T = 0.5 / 36525;
+  const speedOf = (lonAt) => {
+    let diff = lonAt(T + HALF_DAY_T) - lonAt(T - HALF_DAY_T);
+    if (diff > 180) diff -= 360;
+    if (diff < -180) diff += 360;
+    return diff;
+  };
   const sun = sunGeo(T);
+  const sunSpeed = speedOf((t) => sunGeo(t).lon);
   pos["sun"] = {
     key: "sun",
     longitude: sun.lon,
     signIdx: Math.floor(sun.lon / 30),
-    degree: sun.lon % 30
+    degree: sun.lon % 30,
+    speed: sunSpeed,
+    retrograde: false
+    // le Soleil apparent ne rétrograde jamais
   };
   const ml = moonGeo(T);
+  const moonSpeed = speedOf((t) => moonGeo(t));
   pos["moon"] = {
     key: "moon",
     longitude: ml,
     signIdx: Math.floor(ml / 30),
-    degree: ml % 30
+    degree: ml % 30,
+    speed: moonSpeed,
+    retrograde: false
+    // la Lune non plus
   };
   const earthH = helioPos3D("earth", T);
+  const earthH1 = helioPos3D("earth", T - HALF_DAY_T);
+  const earthH2 = helioPos3D("earth", T + HALF_DAY_T);
   OUTER_PLANETS.forEach((k) => {
     const pH = helioPos3D(k, T);
     const lon = helioToGeoLon(pH, earthH);
+    const g1 = helioToGeoLon(helioPos3D(k, T - HALF_DAY_T), earthH1);
+    const g2 = helioToGeoLon(helioPos3D(k, T + HALF_DAY_T), earthH2);
+    let speed = g2 - g1;
+    if (speed > 180) speed -= 360;
+    if (speed < -180) speed += 360;
     pos[k] = {
       key: k,
       longitude: lon,
       signIdx: Math.floor(lon / 30),
-      degree: lon % 30
+      degree: lon % 30,
+      speed,
+      retrograde: speed < 0
     };
   });
   const nn = lunarNode(T);
+  const nodeSpeed = speedOf((t) => lunarNode(t));
   pos["northNode"] = {
     key: "northNode",
     longitude: nn,
     signIdx: Math.floor(nn / 30),
     degree: nn % 30,
-    retrograde: true
+    retrograde: true,
+    speed: nodeSpeed
   };
   const sn = n360(nn + 180);
   pos["southNode"] = {
@@ -573,7 +693,8 @@ function allPositions(JD) {
     longitude: sn,
     signIdx: Math.floor(sn / 30),
     degree: sn % 30,
-    retrograde: true
+    retrograde: true,
+    speed: nodeSpeed
   };
   return pos;
 }
@@ -590,7 +711,7 @@ var ACG_BODY_KEYS = [
   "pluto"
 ];
 function equatorialPositions(JD) {
-  const T = (JD - 2451545) / 36525;
+  const T = ttCenturiesFromUT(JD);
   const eps = obl(T);
   const out = {};
   out["sun"] = eclipticToEquatorial(sunGeo(T).lon, 0, eps);
@@ -640,8 +761,12 @@ function computeChartFromJD(JD, latitude, longitude, opts = {}) {
   }
   const retrogrades = [];
   ["mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"].forEach((k) => {
-    const r = isRetrograde(k, JD);
-    if (planets[k]) planets[k].retrograde = r;
+    const v = angularSpeed(k, JD);
+    const r = v !== void 0 && v < 0;
+    if (planets[k]) {
+      planets[k].retrograde = r;
+      if (v !== void 0) planets[k].speed = v;
+    }
     if (r) retrogrades.push(k);
   });
   const aspects = calculateAspects(planets);
@@ -704,6 +829,9 @@ function loadSwisseph() {
     return false;
   }
 }
+function isSwissephLoaded() {
+  return _swe !== null && _swe !== false;
+}
 function getSwissephLoadError() {
   return _swissephLoadError;
 }
@@ -783,7 +911,11 @@ var HOUSE_SYSTEM_CHAR = {
   placidus: "P",
   koch: "K",
   equal: "E",
-  whole_sign: "W"
+  whole_sign: "W",
+  // HOUSE-SYSTEMS-EXTEND-V1 : codes swisseph natifs.
+  porphyry: "O",
+  regiomontanus: "R",
+  campanus: "C"
 };
 function allPositionsSwiss(JD) {
   if (!loadSwisseph()) throw new Error("swisseph not loaded");
@@ -806,12 +938,14 @@ function allPositionsSwiss(JD) {
       }
       throw new Error(`swe_calc_ut failed for ${key} (ipl=${code}): ${errored ? r.error : "longitude non finie"}`);
     }
+    const speed = typeof r.longitudeSpeed === "number" && Number.isFinite(r.longitudeSpeed) ? r.longitudeSpeed : void 0;
     out[key] = {
       key,
       longitude: lon,
       signIdx: Math.floor(lon / 30),
       degree: lon % 30,
-      retrograde: typeof r.longitudeSpeed === "number" ? r.longitudeSpeed < 0 : false
+      retrograde: speed !== void 0 ? speed < 0 : false,
+      ...speed !== void 0 ? { speed } : {}
     };
   }
   if (out["northNode"]) {
@@ -824,7 +958,9 @@ function allPositionsSwiss(JD) {
       // SOUTH-NODE-RETRO-FIX : le Nœud Sud partage l'axe nodal — il a
       // donc le même mouvement que le Nœud Nord. Sans cette ligne il
       // s'affichait « Direct » alors que le Nœud Nord est rétrograde.
-      retrograde: out["northNode"].retrograde ?? false
+      retrograde: out["northNode"].retrograde ?? false,
+      // TRANSIT-SPEED-V1 : longitude = nord + 180 ⇒ dérivée identique.
+      ...out["northNode"].speed !== void 0 ? { speed: out["northNode"].speed } : {}
     };
   }
   return out;
@@ -991,6 +1127,23 @@ function computeCurrentSkySwiss(lat, lng, opts = {}) {
   const JD = Date.now() / 864e5 + 24405875e-1;
   return computeChartFromJDSwiss(JD, lat, lng, opts);
 }
+function isRetrogradeSwiss(key, JD) {
+  if (!loadSwisseph()) throw new Error("swisseph not loaded");
+  const code = getPlanetIpl()[key];
+  if (typeof code !== "number") return false;
+  const flag = (FILE_BASED_BODIES.has(key) ? _swe.SEFLG_SWIEPH : _swe.SEFLG_MOSEPH) | _swe.SEFLG_SPEED;
+  let r;
+  try {
+    r = _swe.swe_calc_ut(JD, code, flag);
+  } catch (err) {
+    r = { error: err instanceof Error ? err.message : String(err) };
+  }
+  if (r && typeof r === "object" && "error" in r && r.error) {
+    if (OPTIONAL_BODIES.has(key)) return false;
+    throw new Error(`swe_calc_ut failed for ${key}: ${r.error}`);
+  }
+  return typeof r.longitudeSpeed === "number" ? r.longitudeSpeed < 0 : false;
+}
 function moonPhaseSwiss(JD) {
   if (!loadSwisseph()) throw new Error("swisseph not loaded");
   const ipl = getPlanetIpl();
@@ -998,6 +1151,83 @@ function moonPhaseSwiss(JD) {
   const moon = _swe.swe_calc_ut(JD, ipl.moon, _swe.SEFLG_MOSEPH);
   return moonPhaseFromLongitudes(n360(sun.longitude), n360(moon.longitude));
 }
+function decodeSolarRflag(rflag, swe) {
+  if (rflag & (swe.SE_ECL_ANNULAR_TOTAL ?? 8)) return "hybrid";
+  if (rflag & (swe.SE_ECL_TOTAL ?? 1)) return "total";
+  if (rflag & (swe.SE_ECL_ANNULAR ?? 2)) return "annular";
+  return "partial";
+}
+function decodeLunarRflag(rflag, swe) {
+  if (rflag & (swe.SE_ECL_TOTAL ?? 1)) return "total";
+  if (rflag & (swe.SE_ECL_PARTIAL ?? 4)) return "partial";
+  if (rflag & (swe.SE_ECL_PENUMBRAL ?? 16)) return "penumbral";
+  return "penumbral";
+}
+function computeSolarEclipseDetailsSwiss(JD) {
+  if (!loadSwisseph()) return null;
+  try {
+    const r = _swe.swe_sol_eclipse_where(JD, _swe.SEFLG_MOSEPH);
+    if (!r || "error" in r) return null;
+    return {
+      magnitude: r.eclipseMagnitude,
+      obscuration: r.solarDiscFraction,
+      kind: decodeSolarRflag(r.rflag, _swe),
+      saros: r.sarosNumber,
+      sarosMember: r.sarosMember
+    };
+  } catch {
+    return null;
+  }
+}
+function computeLunarEclipseDetailsSwiss(JD) {
+  if (!loadSwisseph()) return null;
+  try {
+    const r = _swe.swe_lun_eclipse_how(JD, _swe.SEFLG_MOSEPH, 0, 0, 0);
+    if (!r || "error" in r) return null;
+    return {
+      magnitude: r.umbralMagnitude,
+      penumbralMagnitude: r.penumbralMagnitude,
+      kind: decodeLunarRflag(r.rflag, _swe),
+      saros: r.sarosNumber,
+      sarosMember: r.sarosMember
+    };
+  } catch {
+    return null;
+  }
+}
+var numOrNull = (v) => typeof v === "number" ? v : null;
+function findNextSolarEclipseSwiss(jdStart, backward = false) {
+  if (!loadSwisseph()) return null;
+  try {
+    const r = _swe.swe_sol_eclipse_when_glob(jdStart, _swe.SEFLG_MOSEPH, 0, backward ? 1 : 0);
+    if (!r || "error" in r || typeof r.maximum !== "number") return null;
+    return {
+      jdMaximum: r.maximum,
+      kind: decodeSolarRflag(r.rflag, _swe),
+      begin: numOrNull(r.begin),
+      end: numOrNull(r.end)
+    };
+  } catch {
+    return null;
+  }
+}
+function findNextLunarEclipseSwiss(jdStart, backward = false) {
+  if (!loadSwisseph()) return null;
+  try {
+    const r = _swe.swe_lun_eclipse_when(jdStart, _swe.SEFLG_MOSEPH, 0, backward ? 1 : 0);
+    if (!r || "error" in r || typeof r.maximum !== "number") return null;
+    return {
+      jdMaximum: r.maximum,
+      kind: decodeLunarRflag(r.rflag, _swe),
+      partialBegin: numOrNull(r.partialBegin),
+      partialEnd: numOrNull(r.partialEnd),
+      penumbralBegin: numOrNull(r.penumbralBegin),
+      penumbralEnd: numOrNull(r.penumbralEnd)
+    };
+  } catch {
+    return null;
+  }
+}
 
 // ../ephemeris/src/engine-router.ts
 var _activeEngine = null;
@@ -1031,6 +1261,16 @@ function resolveEngine() {
 function getActiveEngine() {
   return resolveEngine();
 }
+function getEngineDiagnostic() {
+  const active = resolveEngine();
+  return {
+    active,
+    requested: (process.env["ASTRO_ENGINE"] ?? "swisseph").toLowerCase().trim(),
+    swissephLoaded: isSwissephLoaded(),
+    swissephError: getSwissephLoadError(),
+    resolutionLog: _resolutionLog ?? "(non r\xE9solu)"
+  };
+}
 function computeChartFromJD2(JD, latitude, longitude, opts = {}) {
   if (resolveEngine() === "swisseph") {
     return computeChartFromJDSwiss(JD, latitude, longitude, opts);
@@ -1046,6 +1286,9 @@ function computeCurrentSky2(lat, lng, opts = {}) {
 function allPositions2(JD) {
   return resolveEngine() === "swisseph" ? allPositionsSwiss(JD) : allPositions(JD);
 }
+function isRetrograde3(key, JD) {
+  return resolveEngine() === "swisseph" ? isRetrogradeSwiss(key, JD) : isRetrograde(key, JD);
+}
 function moonPhase2(JD) {
   return resolveEngine() === "swisseph" ? moonPhaseSwiss(JD) : moonPhase(JD);
 }
@@ -1077,6 +1320,419 @@ var CityNotFoundError = class extends Error {
   suggestions;
 };
 
+// ../ephemeris/src/planting-calendar.ts
+function R2(a, b) {
+  const out = [];
+  let m = a;
+  for (let i = 0; i < 12; i++) {
+    out.push(m);
+    if (m === b) break;
+    m = m === 12 ? 1 : m + 1;
+  }
+  return out;
+}
+var VEGETABLES = [
+  // Racines / bulbes
+  { key: "carrot", fr: "carottes", en: "carrots", category: "root", sow: R2(3, 7), harvest: R2(6, 11) },
+  { key: "radish", fr: "radis", en: "radishes", category: "root", sow: R2(3, 9), harvest: R2(4, 10) },
+  { key: "beetroot", fr: "betteraves", en: "beetroot", category: "root", sow: R2(4, 6), harvest: R2(7, 11) },
+  { key: "turnip", fr: "navets", en: "turnips", category: "root", sow: R2(3, 9), harvest: R2(5, 11) },
+  { key: "parsnip", fr: "panais", en: "parsnips", category: "root", sow: R2(3, 5), harvest: R2(10, 2) },
+  { key: "potato", fr: "pommes de terre", en: "potatoes", category: "root", plant: R2(3, 5), harvest: R2(6, 9) },
+  { key: "onion", fr: "oignons", en: "onions", category: "root", sow: R2(2, 4), plant: R2(3, 4), harvest: R2(7, 9) },
+  { key: "garlic", fr: "ail", en: "garlic", category: "root", plant: [10, 11, 12, 2, 3], harvest: R2(6, 7) },
+  { key: "shallot", fr: "\xE9chalotes", en: "shallots", category: "root", plant: R2(10, 3), harvest: R2(6, 7) },
+  { key: "celeriac", fr: "c\xE9leri-rave", en: "celeriac", category: "root", sowUnder: R2(3, 4), plant: R2(5, 6), harvest: R2(9, 11) },
+  { key: "jerusalem_artichoke", fr: "topinambours", en: "Jerusalem artichokes", category: "root", plant: R2(2, 4), harvest: R2(10, 3) },
+  { key: "salsify", fr: "salsifis", en: "salsify", category: "root", sow: R2(4, 5), harvest: R2(10, 2) },
+  // Feuilles
+  { key: "lettuce", fr: "salades", en: "lettuces", category: "leaf", sowUnder: R2(2, 3), sow: R2(3, 9), harvest: R2(4, 11) },
+  { key: "spinach", fr: "\xE9pinards", en: "spinach", category: "leaf", sow: [3, 4, 8, 9], harvest: R2(10, 6) },
+  { key: "leek", fr: "poireaux", en: "leeks", category: "leaf", sow: R2(2, 4), plant: R2(6, 8), harvest: R2(9, 3) },
+  { key: "chard", fr: "blettes", en: "chard", category: "leaf", sow: R2(4, 6), harvest: R2(7, 11) },
+  { key: "lambs_lettuce", fr: "m\xE2che", en: "lamb's lettuce", category: "leaf", sow: R2(8, 9), harvest: R2(10, 3) },
+  { key: "cabbage", fr: "choux pomm\xE9s", en: "cabbages", category: "leaf", sowUnder: R2(3, 4), plant: R2(5, 7), harvest: R2(9, 2) },
+  { key: "kale", fr: "chou fris\xE9", en: "kale", category: "leaf", sow: R2(4, 6), plant: R2(6, 7), harvest: R2(10, 2) },
+  { key: "brussels", fr: "choux de Bruxelles", en: "Brussels sprouts", category: "leaf", sowUnder: R2(3, 4), plant: R2(5, 6), harvest: R2(10, 2) },
+  { key: "rocket", fr: "roquette", en: "rocket", category: "leaf", sow: R2(3, 9), harvest: R2(4, 10) },
+  { key: "parsley", fr: "persil", en: "parsley", category: "leaf", sow: R2(3, 7), harvest: R2(5, 11) },
+  { key: "chicory", fr: "endives", en: "chicory", category: "leaf", sow: R2(5, 6), harvest: R2(10, 2) },
+  { key: "fennel", fr: "fenouil", en: "fennel", category: "leaf", sow: R2(5, 7), harvest: R2(8, 11) },
+  { key: "basil", fr: "basilic", en: "basil", category: "leaf", sowUnder: R2(3, 4), plant: [5], harvest: R2(6, 9) },
+  { key: "chives", fr: "ciboulette", en: "chives", category: "leaf", plant: R2(3, 5), harvest: R2(4, 10) },
+  { key: "sorrel", fr: "oseille", en: "sorrel", category: "leaf", sow: R2(3, 5), harvest: R2(5, 10) },
+  // Fleurs (comestibles / inflorescences)
+  { key: "cauliflower", fr: "choux-fleurs", en: "cauliflowers", category: "flower", sowUnder: R2(3, 4), plant: R2(5, 6), harvest: R2(9, 11) },
+  { key: "broccoli", fr: "brocolis", en: "broccoli", category: "flower", sow: R2(3, 5), plant: R2(5, 6), harvest: R2(8, 11) },
+  { key: "artichoke", fr: "artichauts", en: "artichokes", category: "flower", plant: R2(3, 4), harvest: R2(6, 9) },
+  // Fruits (légumes-fruits)
+  { key: "tomato", fr: "tomates", en: "tomatoes", category: "fruit", sowUnder: R2(2, 4), plant: [5], harvest: R2(7, 10) },
+  { key: "courgette", fr: "courgettes", en: "courgettes", category: "fruit", sowUnder: R2(3, 4), sow: [5], plant: R2(5, 6), harvest: R2(6, 10) },
+  { key: "cucumber", fr: "concombres", en: "cucumbers", category: "fruit", sowUnder: R2(3, 4), plant: R2(5, 6), harvest: R2(7, 9) },
+  { key: "gherkin", fr: "cornichons", en: "gherkins", category: "fruit", sow: [5], harvest: R2(7, 9) },
+  { key: "squash", fr: "courges", en: "squash", category: "fruit", sowUnder: [4], sow: [5], harvest: R2(9, 11) },
+  { key: "green_bean", fr: "haricots verts", en: "green beans", category: "fruit", sow: R2(5, 7), harvest: R2(7, 10) },
+  { key: "shell_bean", fr: "haricots \xE0 \xE9cosser", en: "shelling beans", category: "fruit", sow: R2(5, 6), harvest: R2(8, 10) },
+  { key: "pea", fr: "petits pois", en: "peas", category: "fruit", sow: [2, 3, 4, 10, 11], harvest: R2(5, 7) },
+  { key: "broad_bean", fr: "f\xE8ves", en: "broad beans", category: "fruit", sow: [2, 3, 4, 10, 11], harvest: R2(5, 7) },
+  { key: "pepper", fr: "poivrons", en: "peppers", category: "fruit", sowUnder: R2(2, 3), plant: [5], harvest: R2(7, 10) },
+  { key: "eggplant", fr: "aubergines", en: "eggplants", category: "fruit", sowUnder: R2(2, 3), plant: [5], harvest: R2(7, 10) },
+  { key: "chilli", fr: "piments", en: "chillies", category: "fruit", sowUnder: R2(2, 3), plant: [5], harvest: R2(8, 10) },
+  { key: "melon", fr: "melons", en: "melons", category: "fruit", sowUnder: R2(3, 4), plant: [5], harvest: R2(7, 9) },
+  { key: "sweetcorn", fr: "ma\xEFs doux", en: "sweetcorn", category: "fruit", sow: R2(4, 6), harvest: R2(8, 10) },
+  { key: "strawberry", fr: "fraises", en: "strawberries", category: "fruit", plant: [3, 4, 8, 9], harvest: R2(5, 7) }
+];
+var FLOWERS = [
+  // Annuelles (semis)
+  { key: "cosmos", fr: "cosmos", en: "cosmos", category: "flower", sow: R2(4, 6), harvest: R2(7, 10) },
+  { key: "zinnia", fr: "zinnias", en: "zinnias", category: "flower", sowUnder: R2(3, 4), sow: [5], harvest: R2(7, 10) },
+  { key: "calendula", fr: "soucis", en: "marigolds (calendula)", category: "flower", sow: R2(3, 6), harvest: R2(5, 10) },
+  { key: "nasturtium", fr: "capucines", en: "nasturtiums", category: "flower", sow: R2(4, 6), harvest: R2(6, 10) },
+  { key: "sunflower", fr: "tournesols", en: "sunflowers", category: "flower", sow: R2(4, 6), harvest: R2(7, 9) },
+  { key: "tagetes", fr: "\u0153illets d'Inde", en: "French marigolds", category: "flower", sowUnder: R2(3, 4), plant: [5], harvest: R2(6, 10) },
+  { key: "sweet_pea", fr: "pois de senteur", en: "sweet peas", category: "flower", sow: R2(2, 4), harvest: R2(6, 9) },
+  { key: "cornflower", fr: "bleuets", en: "cornflowers", category: "flower", sow: [3, 4, 5, 9], harvest: R2(6, 8) },
+  { key: "poppy", fr: "coquelicots", en: "poppies", category: "flower", sow: [3, 4, 5, 9], harvest: R2(5, 7) },
+  { key: "nigella", fr: "nigelles", en: "love-in-a-mist", category: "flower", sow: [3, 4, 5, 9], harvest: R2(6, 8) },
+  { key: "aster", fr: "reines-marguerites", en: "asters", category: "flower", sow: R2(4, 5), harvest: R2(8, 10) },
+  // Bisannuelles
+  { key: "hollyhock", fr: "roses tr\xE9mi\xE8res", en: "hollyhocks", category: "flower", sow: R2(5, 7), harvest: R2(6, 8) },
+  { key: "foxglove", fr: "digitales", en: "foxgloves", category: "flower", sow: R2(5, 7), harvest: R2(6, 7) },
+  { key: "forget_me_not", fr: "myosotis", en: "forget-me-nots", category: "flower", sow: R2(6, 7), harvest: R2(3, 5) },
+  { key: "pansy", fr: "pens\xE9es", en: "pansies", category: "flower", sow: R2(6, 8), plant: [9, 10, 3], harvest: [3, 4, 5, 10, 11] },
+  // Vivaces / bulbes (plantation)
+  { key: "dahlia", fr: "dahlias", en: "dahlias", category: "flower", plant: R2(4, 5), harvest: R2(7, 10) },
+  { key: "gladiolus", fr: "gla\xEFeuls", en: "gladioli", category: "flower", plant: R2(3, 6), harvest: R2(7, 9) },
+  { key: "tulip", fr: "tulipes", en: "tulips", category: "flower", plant: R2(10, 12), harvest: R2(3, 5) },
+  { key: "daffodil", fr: "narcisses", en: "daffodils", category: "flower", plant: R2(9, 11), harvest: R2(3, 4) },
+  { key: "crocus", fr: "crocus", en: "crocuses", category: "flower", plant: R2(9, 11), harvest: R2(2, 3) },
+  { key: "hyacinth", fr: "jacinthes", en: "hyacinths", category: "flower", plant: R2(9, 11), harvest: R2(3, 4) },
+  { key: "lily", fr: "lys", en: "lilies", category: "flower", plant: R2(10, 4), harvest: R2(6, 8) },
+  { key: "peony", fr: "pivoines", en: "peonies", category: "flower", plant: R2(9, 11), harvest: R2(5, 6) },
+  { key: "iris", fr: "iris", en: "irises", category: "flower", plant: R2(7, 9), harvest: R2(5, 6) },
+  { key: "lily_valley", fr: "muguet", en: "lily of the valley", category: "flower", plant: R2(10, 11), harvest: [5] },
+  { key: "rose", fr: "rosiers", en: "roses", category: "flower", plant: [11, 12, 1, 2, 3], harvest: R2(5, 10) },
+  { key: "lavender", fr: "lavande", en: "lavender", category: "flower", plant: [3, 4, 5, 9, 10], harvest: R2(6, 8) },
+  { key: "chrysanthemum", fr: "chrysanth\xE8mes", en: "chrysanthemums", category: "flower", plant: R2(5, 6), harvest: R2(9, 11) }
+];
+var PLANTING_CALENDAR = [...VEGETABLES, ...FLOWERS];
+
+// ../ephemeris/src/dignities.ts
+var TABLE = {
+  sun: { domicile: [4], exaltation: [0], detriment: [10], fall: [6] },
+  moon: { domicile: [3], exaltation: [1], detriment: [9], fall: [7] },
+  mercury: { domicile: [2, 5], exaltation: [5], detriment: [8, 11], fall: [11] },
+  venus: { domicile: [1, 6], exaltation: [11], detriment: [0, 7], fall: [5] },
+  mars: { domicile: [0, 7], exaltation: [9], detriment: [1, 6], fall: [3] },
+  jupiter: { domicile: [8, 11], exaltation: [3], detriment: [2, 5], fall: [9] },
+  saturn: { domicile: [9, 10], exaltation: [6], detriment: [3, 4], fall: [0] }
+};
+var LABELS = {
+  domicile: { fr: "en domicile", en: "in domicile" },
+  exaltation: { fr: "en exaltation", en: "exalted" },
+  detriment: { fr: "en exil", en: "in detriment" },
+  fall: { fr: "en chute", en: "in fall" }
+};
+var PRIORITY = ["domicile", "exaltation", "detriment", "fall"];
+function essentialDignity(planetKey, signIdx) {
+  const key = typeof planetKey === "string" ? planetKey.toLowerCase() : "";
+  const row = TABLE[key];
+  if (!row || signIdx == null || !Number.isInteger(signIdx) || signIdx < 0 || signIdx > 11) {
+    return null;
+  }
+  for (const kind of PRIORITY) {
+    if (row[kind].includes(signIdx)) {
+      return { kind, labelFr: LABELS[kind].fr, labelEn: LABELS[kind].en };
+    }
+  }
+  return null;
+}
+
+// ../ephemeris/src/natal-weight.ts
+var TRADITIONAL_RULER = [
+  "mars",
+  // 0  Bélier
+  "venus",
+  // 1  Taureau
+  "mercury",
+  // 2  Gémeaux
+  "moon",
+  // 3  Cancer
+  "sun",
+  // 4  Lion
+  "mercury",
+  // 5  Vierge
+  "venus",
+  // 6  Balance
+  "mars",
+  // 7  Scorpion
+  "jupiter",
+  // 8  Sagittaire
+  "saturn",
+  // 9  Capricorne
+  "saturn",
+  // 10 Verseau
+  "jupiter"
+  // 11 Poissons
+];
+var W = {
+  ascRuler: 0.45,
+  // maître d'ascendant
+  sunRuler: 0.22,
+  // maître du signe solaire
+  angular: 0.2,
+  // en maison angulaire (1/4/7/10)
+  conjAngle: 0.28,
+  // à ≤ 5° de l'Ascendant ou du MC
+  luminary: 0.16,
+  // Soleil / Lune (base)
+  tightAspectCore: 0.18,
+  // aspect natal serré (<2°) impliquant un luminaire ou le maître
+  tightAspect: 0.1,
+  // aspect natal serré (<2°) sinon
+  dignity: 0.1
+  // domicile ou exaltation
+};
+var CONJ_ANGLE_ORB = 5;
+var TIGHT_ORB = 2;
+var TOP_THRESHOLD = 0.25;
+var TOP_MAX = 3;
+var LUMINARIES = /* @__PURE__ */ new Set(["sun", "moon"]);
+var ANGULAR_HOUSES = /* @__PURE__ */ new Set([1, 4, 7, 10]);
+function angularSep(a, b) {
+  let d = Math.abs(a - b) % 360;
+  if (d > 180) d = 360 - d;
+  return d;
+}
+function signOf(p) {
+  return p.signIdx ?? Math.floor((p.longitude % 360 + 360) % 360 / 30);
+}
+function computeNatalWeight(chart) {
+  const timeKnown = chart.birthTimeKnown ?? true;
+  const planets = chart.planets ?? {};
+  const acc = {};
+  const add = (planet, delta, role) => {
+    if (!planet || !planets[planet]) return;
+    const e = acc[planet] ?? (acc[planet] = { weight: 0, roles: [] });
+    e.weight += delta;
+    if (!e.roles.some((r) => r.key === role.key)) e.roles.push(role);
+  };
+  let chartRuler = null;
+  if (timeKnown && typeof chart.asc === "number") {
+    const ascSign = Math.floor((chart.asc % 360 + 360) % 360 / 30);
+    chartRuler = TRADITIONAL_RULER[ascSign] ?? null;
+    if (chartRuler) {
+      add(chartRuler, W.ascRuler, { key: "ascRuler", labelFr: "ma\xEEtre d'ascendant", labelEn: "chart ruler" });
+    }
+  }
+  const sun = planets["sun"];
+  if (sun) {
+    const sunRuler = TRADITIONAL_RULER[signOf(sun)];
+    if (sunRuler) {
+      add(sunRuler, W.sunRuler, { key: "sunRuler", labelFr: "ma\xEEtre du Soleil", labelEn: "ruler of the Sun" });
+    }
+  }
+  for (const lum of LUMINARIES) {
+    if (planets[lum]) add(lum, W.luminary, { key: "luminary", labelFr: "luminaire", labelEn: "luminary" });
+  }
+  if (timeKnown) {
+    for (const [key, p] of Object.entries(planets)) {
+      if (!p || typeof p.longitude !== "number") continue;
+      if (p.house != null && ANGULAR_HOUSES.has(p.house)) {
+        add(key, W.angular, { key: "angular", labelFr: "angulaire", labelEn: "angular" });
+      }
+      if (typeof chart.asc === "number" && angularSep(p.longitude, chart.asc) <= CONJ_ANGLE_ORB) {
+        add(key, W.conjAngle, { key: "conjAsc", labelFr: "conjoint \xE0 l'Ascendant", labelEn: "conjunct the Ascendant" });
+      }
+      if (typeof chart.mc === "number" && angularSep(p.longitude, chart.mc) <= CONJ_ANGLE_ORB) {
+        add(key, W.conjAngle, { key: "conjMc", labelFr: "conjoint au Milieu du Ciel", labelEn: "conjunct the Midheaven" });
+      }
+    }
+  }
+  for (const asp of chart.aspects ?? []) {
+    if (typeof asp.orb !== "number" || asp.orb >= TIGHT_ORB) continue;
+    const a = asp.planet1 ?? asp.p1;
+    const b = asp.planet2 ?? asp.p2;
+    if (!a || !b) continue;
+    const core = LUMINARIES.has(a) || LUMINARIES.has(b) || a === chartRuler || b === chartRuler;
+    const delta = core ? W.tightAspectCore : W.tightAspect;
+    const role = { key: "tightAspect", labelFr: "aspect natal serr\xE9", labelEn: "tight natal aspect" };
+    add(a, delta, role);
+    add(b, delta, role);
+  }
+  for (const [key, p] of Object.entries(planets)) {
+    if (!p || typeof p.longitude !== "number") continue;
+    const dig = essentialDignity(key, signOf(p));
+    if (dig && (dig.kind === "domicile" || dig.kind === "exaltation")) {
+      add(key, W.dignity, { key: "dignity", labelFr: dig.labelFr, labelEn: dig.labelEn });
+    }
+  }
+  const byPlanet = {};
+  for (const [planet, e] of Object.entries(acc)) {
+    byPlanet[planet] = { planet, weight: Math.min(1, Math.round(e.weight * 100) / 100), roles: e.roles };
+  }
+  const top = Object.values(byPlanet).filter((e) => e.weight >= TOP_THRESHOLD).sort((x, y) => y.weight - x.weight).slice(0, TOP_MAX);
+  return { byPlanet, top, chartRuler };
+}
+
+// ../ephemeris/src/natal-patterns.ts
+var MAJORS = ["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"];
+var ORB = {
+  grandTrine: 8,
+  square: 7,
+  // T-carré / grande croix
+  opposition: 7,
+  yodSextile: 4,
+  yodQuincunx: 3
+};
+var STELLIUM_MIN = 3;
+function sep(a, b) {
+  let d = Math.abs(a - b) % 360;
+  if (d > 180) d = 360 - d;
+  return d;
+}
+function isAspect(a, b, angle, orb) {
+  return Math.abs(sep(a, b) - angle) <= orb;
+}
+function signOf2(p) {
+  return p.signIdx ?? Math.floor((p.longitude % 360 + 360) % 360 / 30);
+}
+var ELEMENT_FR = ["Feu", "Terre", "Air", "Eau"];
+var ELEMENT_EN = ["Fire", "Earth", "Air", "Water"];
+function detectNatalPatterns(input) {
+  const timeKnown = input.birthTimeKnown ?? true;
+  const bodies = MAJORS.filter((k) => {
+    const p = input.planets?.[k];
+    return p && typeof p.longitude === "number";
+  });
+  const lon = (k) => input.planets[k].longitude;
+  const out = [];
+  const bySign = /* @__PURE__ */ new Map();
+  for (const k of bodies) {
+    const s = signOf2(input.planets[k]);
+    (bySign.get(s) ?? bySign.set(s, []).get(s)).push(k);
+  }
+  for (const [s, members] of bySign) {
+    if (members.length >= STELLIUM_MIN) {
+      out.push({
+        kind: "stellium",
+        by: "sign",
+        signIdx: s,
+        planets: members,
+        typeFr: "stellium",
+        typeEn: "stellium"
+      });
+    }
+  }
+  if (timeKnown) {
+    const byHouse = /* @__PURE__ */ new Map();
+    for (const k of bodies) {
+      const h = input.planets[k].house;
+      if (h != null) (byHouse.get(h) ?? byHouse.set(h, []).get(h)).push(k);
+    }
+    for (const [h, members] of byHouse) {
+      if (members.length >= STELLIUM_MIN) {
+        const sameAsSign = out.some((p) => p.kind === "stellium" && p.by === "sign" && p.planets.length === members.length && members.every((m) => p.planets.includes(m)));
+        if (!sameAsSign) {
+          out.push({
+            kind: "stellium",
+            by: "house",
+            house: h,
+            planets: members,
+            typeFr: "stellium",
+            typeEn: "stellium"
+          });
+        }
+      }
+    }
+  }
+  const grandTrines = [];
+  for (let i = 0; i < bodies.length; i++)
+    for (let j = i + 1; j < bodies.length; j++)
+      for (let k = j + 1; k < bodies.length; k++) {
+        const [a, b, c] = [bodies[i], bodies[j], bodies[k]];
+        if (isAspect(lon(a), lon(b), 120, ORB.grandTrine) && isAspect(lon(b), lon(c), 120, ORB.grandTrine) && isAspect(lon(a), lon(c), 120, ORB.grandTrine)) {
+          const els = [a, b, c].map((x) => signOf2(input.planets[x]) % 4);
+          const element = els.every((e) => e === els[0]) ? els[0] : void 0;
+          grandTrines.push([a, b, c]);
+          out.push({
+            kind: "grandTrine",
+            planets: [a, b, c],
+            element,
+            typeFr: element != null ? `grand trigone de ${ELEMENT_FR[element]}` : "grand trigone",
+            typeEn: element != null ? `grand trine in ${ELEMENT_EN[element]}` : "grand trine"
+          });
+        }
+      }
+  const opps = [];
+  for (let i = 0; i < bodies.length; i++)
+    for (let j = i + 1; j < bodies.length; j++)
+      if (isAspect(lon(bodies[i]), lon(bodies[j]), 180, ORB.opposition))
+        opps.push([bodies[i], bodies[j]]);
+  const squares = (x, y) => isAspect(lon(x), lon(y), 90, ORB.square);
+  const crossSets = [];
+  for (let i = 0; i < opps.length; i++)
+    for (let j = i + 1; j < opps.length; j++) {
+      const [a, b] = opps[i], [c, d] = opps[j];
+      const four = [a, b, c, d];
+      if (new Set(four).size !== 4) continue;
+      if (squares(a, c) && squares(a, d) && squares(b, c) && squares(b, d)) {
+        crossSets.push(new Set(four));
+        out.push({ kind: "grandCross", planets: four, typeFr: "grande croix", typeEn: "grand cross" });
+      }
+    }
+  for (const [a, b] of opps) {
+    for (const c of bodies) {
+      if (c === a || c === b) continue;
+      if (squares(a, c) && squares(b, c)) {
+        if (crossSets.some((s) => s.has(a) && s.has(b) && s.has(c))) continue;
+        out.push({ kind: "tSquare", planets: [a, b, c], apex: c, typeFr: "T-carr\xE9", typeEn: "T-square" });
+      }
+    }
+  }
+  for (let i = 0; i < bodies.length; i++)
+    for (let j = i + 1; j < bodies.length; j++) {
+      const a = bodies[i], b = bodies[j];
+      if (!isAspect(lon(a), lon(b), 60, ORB.yodSextile)) continue;
+      for (const c of bodies) {
+        if (c === a || c === b) continue;
+        if (isAspect(lon(a), lon(c), 150, ORB.yodQuincunx) && isAspect(lon(b), lon(c), 150, ORB.yodQuincunx)) {
+          out.push({ kind: "yod", planets: [a, b, c], apex: c, typeFr: "yod", typeEn: "yod" });
+        }
+      }
+    }
+  return out;
+}
+
+// ../ephemeris/src/planetary-ages.ts
+var AGE_BANDS = [
+  { maxAge: 7, planetKey: "moon", fr: "l'enfance, le lien affectif et le besoin de s\xE9curit\xE9", en: "childhood, emotional bonding and the need for security" },
+  { maxAge: 14, planetKey: "mercury", fr: "l'apprentissage, la curiosit\xE9 et les premiers \xE9changes", en: "learning, curiosity and first exchanges" },
+  { maxAge: 24, planetKey: "venus", fr: "l'amour, la sensualit\xE9 et le go\xFBt de plaire", en: "love, sensuality and the taste for pleasing" },
+  { maxAge: 36, planetKey: "mars", fr: "l'affirmation de soi, la conqu\xEAte et l'action", en: "self-assertion, conquest and action" },
+  { maxAge: 48, planetKey: "sun", fr: "la r\xE9ussite, le rayonnement et l'autorit\xE9", en: "achievement, radiance and authority" },
+  { maxAge: 63, planetKey: "jupiter", fr: "le d\xE9ploiement, la transmission et l'expansion", en: "growth, transmission and expansion" },
+  { maxAge: Number.POSITIVE_INFINITY, planetKey: "saturn", fr: "le bilan, la sagesse et l'essentiel", en: "reckoning, wisdom and the essential" }
+];
+
+// ../ephemeris/src/birth-lunation.ts
+var LUNATION_TYPES = [
+  { key: "new", nameFr: "Nouvelle Lune", nameEn: "New Moon", glossFr: "instinct, \xE9lan spontan\xE9, commencement subjectif", glossEn: "instinct, spontaneous drive, subjective beginnings" },
+  { key: "crescent", nameFr: "Croissant", nameEn: "Crescent", glossFr: "l'effort d'\xE9merger, s'arracher au pass\xE9, volont\xE9 d'avancer", glossEn: "the effort to emerge, breaking from the past, will to advance" },
+  { key: "first_quarter", nameFr: "Premier Quartier", nameEn: "First Quarter", glossFr: "crise d'action, construire, bousculer les r\xE9sistances", glossEn: "crisis of action, building, pushing through resistance" },
+  { key: "gibbous", nameFr: "Gibbeuse", nameEn: "Gibbous", glossFr: "perfectionnement, qu\xEAte de sens, analyse, d\xE9vouement", glossEn: "refinement, search for meaning, analysis, devotion" },
+  { key: "full", nameFr: "Pleine Lune", nameEn: "Full Moon", glossFr: "pleine conscience, relation, objectivit\xE9, r\xE9v\xE9lation", glossEn: "full awareness, relationship, objectivity, revelation" },
+  { key: "disseminating", nameFr: "Diffusante", nameEn: "Disseminating", glossFr: "transmettre, partager, enseigner ce qu'on a compris", glossEn: "transmitting, sharing, teaching what one has grasped" },
+  { key: "last_quarter", nameFr: "Dernier Quartier", nameEn: "Last Quarter", glossFr: "crise de conscience, r\xE9orientation, remise en question", glossEn: "crisis of consciousness, reorientation, questioning" },
+  { key: "balsamic", nameFr: "Balsamique", nameEn: "Balsamic", glossFr: "l\xE2cher-prise, transition, graine du futur, retrait", glossEn: "release, transition, seed of the future, withdrawal" }
+];
+function lunationType(sunLon, moonLon) {
+  if (!Number.isFinite(sunLon) || !Number.isFinite(moonLon)) return null;
+  const elong = ((moonLon - sunLon) % 360 + 360) % 360;
+  const idx = Math.min(7, Math.floor(elong / 45));
+  return LUNATION_TYPES[idx];
+}
+
 // ../ephemeris/src/time-utc.service.ts
 import { DateTime } from "luxon";
 var TimezoneError = class extends Error {
@@ -1274,8 +1930,27 @@ function enrich(result, meta) {
     symbol: a.symbol,
     tone: a.tone
   }));
-  return {
+  const planets = {};
+  for (const [key, p] of Object.entries(result.planets)) {
+    const signIdx = p.signIdx ?? Math.floor((p.longitude % 360 + 360) % 360 / 30);
+    planets[key] = { ...p, dignity: essentialDignity(key, signIdx) };
+  }
+  const sunLon = result.planets?.sun?.longitude;
+  const moonLon = result.planets?.moon?.longitude;
+  const lunation = typeof sunLon === "number" && typeof moonLon === "number" ? lunationType(sunLon, moonLon) : null;
+  const weight = computeNatalWeight({
+    planets: result.planets,
+    asc: result.houses.asc ?? null,
+    mc: result.houses.mc ?? null,
+    aspects: result.aspects,
+    birthTimeKnown: meta.birthTimeKnown
+  });
+  const patterns = detectNatalPatterns({
     planets: result.planets,
+    birthTimeKnown: meta.birthTimeKnown
+  });
+  return {
+    planets,
     houses,
     asc: result.houses.asc,
     mc: result.houses.mc,
@@ -1288,6 +1963,12 @@ function enrich(result, meta) {
     moonPhase: result.moonPhase,
     numerology: meta.localBirthDate ? computeLifePath(meta.localBirthDate) : result.numerology,
     // STAB-PRE-5-V1
+    lunation,
+    // NATAL-EXPOSE-V1
+    weight,
+    // NATAL-EXPOSE-V1
+    patterns,
+    // NATAL-EXPOSE-V1
     source: result.source,
     zodiac: result.zodiac,
     houseSystem: result.houseSystem,
@@ -1312,7 +1993,7 @@ function chartCacheKey(args) {
     e: getActiveEngine()
   });
   const hash = createHash("sha256").update(payload).digest("hex").slice(0, 16);
-  return `chart:v7:${args.natalId}:${hash}`;
+  return `chart:v8:${args.natalId}:${hash}`;
 }
 var EphemerisService = class {
   /**
@@ -1413,6 +2094,33 @@ var EphemerisService = class {
       longitude: city.lng
     });
   }
+  // ──────────────────────────────────────────────────────
+  // SYNASTRY-DECAN-V1
+  // Thème « décan » : positions planétaires calculées à midi UTC
+  // (ou à l'heure fournie) SANS lieu de naissance. Les longitudes
+  // écliptiques géocentriques ne dépendent que du temps (JD), pas
+  // de lat/lon — seuls les maisons/ASC/MC en dépendent, et on les
+  // ignore en aval (mode décan : Soleil + planètes lentes only).
+  // Utilisé en synastrie quand un partenaire n'a ni heure ni ville.
+  // ──────────────────────────────────────────────────────
+  /**
+   * @param birthDate      Date de naissance locale (YYYY-MM-DD).
+   * @param birthTime      Heure locale (HH:MM). Défaut 12:00 si absente.
+   * @param birthTimeKnown Propagé dans meta pour le hedging IA.
+   */
+  async calculateDecanChart(args) {
+    const localBirthTime = args.birthTime ?? "12:00";
+    const key = createHash("sha256").update(`decan:${args.birthDate}:${localBirthTime}:${args.birthTimeKnown}`).digest("hex").slice(0, 12);
+    return this.calculateNatalChart({
+      natalId: `decan-${key}`,
+      localBirthDate: args.birthDate,
+      localBirthTime,
+      ianaTz: "UTC",
+      latitude: 0,
+      longitude: 0,
+      birthTimeKnown: args.birthTimeKnown
+    });
+  }
   /** Ciel du moment présent (transits) pour une position. */
   async getCurrentSky(latitude, longitude, opts = {}) {
     const result = computeCurrentSky2(latitude, longitude, opts);
@@ -1427,6 +2135,30 @@ var EphemerisService = class {
       utcISO: nowIso
     });
   }
+  /**
+   * Ciel à un instant précis (JD UT) pour une position — variante déterministe
+   * de `getCurrentSky`.
+   *
+   * HOROSCOPE-CHIP-COHERENCE-V1 : sert à ancrer les aspects transit→natal qui
+   * pilotent les « pastilles d'énergies » et la prose IA sur un MÊME instant
+   * stable du jour (midi UTC), au lieu du « maintenant » horaire. Sans cet
+   * ancrage, la prose (cachée au premier chargement) et les puces (recalculées
+   * en direct à chaque requête) divergeaient dès qu'un corps rapide (Lune,
+   * astéroïde) franchissait un seuil d'orbe dans la journée.
+   */
+  async getSkyAt(JD, latitude, longitude, opts = {}) {
+    const result = computeChartFromJD2(JD, latitude, longitude, opts);
+    const iso = new Date((JD - 24405875e-1) * 864e5).toISOString();
+    return enrich(result, {
+      localBirthDate: iso.slice(0, 10),
+      localBirthTime: iso.slice(11, 16),
+      ianaTz: "UTC",
+      offsetMinutes: 0,
+      resolution: "valid",
+      birthTimeKnown: true,
+      utcISO: iso
+    });
+  }
   // ──────────────────────────────────────────────────────
   // LEGACY — conservé pour compat pendant la migration
   // ──────────────────────────────────────────────────────
@@ -1478,9 +2210,7 @@ var EphemerisService = class {
 };
 var ephemerisService = new EphemerisService();
 
-// src/index.ts
-process.env["EPHEMERIS_DISABLE_REDIS"] ??= "1";
-process.env["ASTRO_ALLOW_FALLBACK"] ??= "true";
+// src/astro-tools.ts
 var SIGNS_FR = [
   "B\xE9lier",
   "Taureau",
@@ -1495,9 +2225,160 @@ var SIGNS_FR = [
   "Verseau",
   "Poissons"
 ];
-function jdFromDate(d) {
-  return d.getTime() / 864e5 + 24405875e-1;
+var JD_UNIX_EPOCH = 24405875e-1;
+var MS_PER_DAY = 864e5;
+var JULIAN_YEAR = 365.25;
+function jdToDate(jd2) {
+  return new Date((jd2 - JD_UNIX_EPOCH) * MS_PER_DAY);
+}
+function dateToJd(d) {
+  return d.getTime() / MS_PER_DAY + JD_UNIX_EPOCH;
+}
+function n3602(x) {
+  return (x % 360 + 360) % 360;
+}
+function wrap1802(x) {
+  return ((x + 180) % 360 + 360) % 360 - 180;
+}
+function angularSep2(a, b) {
+  return Math.abs(wrap1802(a - b));
+}
+function signIdxOf(lon) {
+  return Math.floor(n3602(lon) / 30) % 12;
+}
+function circularMidpoint(a, b) {
+  return n3602(a + wrap1802(b - a) / 2);
+}
+function bodyLongitude(key, jd2) {
+  return allPositions2(jd2)[key]?.longitude;
+}
+var NOISE_KEYS = /* @__PURE__ */ new Set([
+  "fortune",
+  "southNode",
+  "ceres",
+  "pallas",
+  "juno",
+  "vesta",
+  "lilithTrue"
+]);
+function crossAspects(left, right) {
+  const out = [];
+  for (const [lk, lp] of Object.entries(left)) {
+    if (NOISE_KEYS.has(lk)) continue;
+    for (const [rk, rp] of Object.entries(right)) {
+      if (NOISE_KEYS.has(rk)) continue;
+      const sep2 = angularSep2(lp.longitude, rp.longitude);
+      for (const a of ASPECT_TYPES) {
+        const isLum = lk === "sun" || lk === "moon" || rk === "sun" || rk === "moon";
+        const maxOrb = a.orb + (isLum ? 2 : 0);
+        const o = Math.abs(sep2 - a.angle);
+        if (o <= maxOrb) {
+          out.push({
+            a: lk,
+            b: rk,
+            type: a.type,
+            typeFr: a.nameFr,
+            symbol: a.symbol,
+            tone: a.tone,
+            orb: Number(o.toFixed(2)),
+            exact: o < 1
+          });
+        }
+      }
+    }
+  }
+  return out.sort((x, y) => x.orb - y.orb);
+}
+function toneSummary(aspects) {
+  let harmoniques = 0, tensions = 0, neutres = 0;
+  for (const a of aspects) {
+    if (a.tone === "h") harmoniques++;
+    else if (a.tone === "t") tensions++;
+    else neutres++;
+  }
+  return { total: aspects.length, harmoniques, tensions, neutres };
 }
+function compositePositions(a, b) {
+  const out = [];
+  for (const key of Object.keys(a)) {
+    if (NOISE_KEYS.has(key)) continue;
+    const bp = b[key];
+    if (!bp) continue;
+    const lon = circularMidpoint(a[key].longitude, bp.longitude);
+    out.push({ corps: key, longitude: Number(lon.toFixed(4)), signIdx: signIdxOf(lon) });
+  }
+  return out;
+}
+var MAX_ITERS = 42;
+function bisectZero(f, j0, j1) {
+  let lo = j0, hi = j1;
+  for (let i = 0; i < MAX_ITERS; i++) {
+    const mid = (lo + hi) / 2;
+    if (f(mid) <= 0) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+function bisectFlip(value, j0, j1) {
+  const v0 = value(j0);
+  let lo = j0, hi = j1;
+  for (let i = 0; i < MAX_ITERS; i++) {
+    const mid = (lo + hi) / 2;
+    if (value(mid) === v0) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+function findLongitudeReturn(key, target, jdStart, jdEnd, step) {
+  const f = (jd2) => wrap1802((bodyLongitude(key, jd2) ?? NaN) - target);
+  let prev = jdStart;
+  let fprev = f(prev);
+  for (let jd2 = jdStart + step; jd2 <= jdEnd + 1e-9; jd2 += step) {
+    const fcur = f(jd2);
+    if (fprev <= 0 && fcur > 0 && fcur - fprev < 180) {
+      return bisectZero(f, prev, jd2);
+    }
+    prev = jd2;
+    fprev = fcur;
+  }
+  return null;
+}
+function findIngresses(key, jdStart, jdEnd, step) {
+  const sIdx = (jd2) => signIdxOf(bodyLongitude(key, jd2) ?? NaN);
+  const out = [];
+  let prev = jdStart;
+  let sPrev = sIdx(prev);
+  for (let jd2 = jdStart + step; jd2 <= jdEnd + 1e-9; jd2 += step) {
+    const sCur = sIdx(jd2);
+    if (sCur !== sPrev) {
+      const tJd = bisectFlip(sIdx, prev, jd2);
+      out.push({ jd: tJd, deSigneIdx: sPrev, versSigneIdx: sIdx(tJd + 1e-6) });
+    }
+    prev = jd2;
+    sPrev = sCur;
+  }
+  return out;
+}
+function findRetrogradeStations(key, jdStart, jdEnd, step) {
+  const retro = (jd2) => isRetrograde3(key, jd2);
+  const out = [];
+  let prev = jdStart;
+  let rPrev = retro(prev);
+  for (let jd2 = jdStart + step; jd2 <= jdEnd + 1e-9; jd2 += step) {
+    const rCur = retro(jd2);
+    if (rCur !== rPrev) {
+      const tJd = bisectFlip(retro, prev, jd2);
+      out.push({ jd: tJd, station: retro(tJd + 1e-6) ? "retrograde" : "direct" });
+    }
+    prev = jd2;
+    rPrev = rCur;
+  }
+  return out;
+}
+
+// src/index.ts
+process.env["EPHEMERIS_DISABLE_REDIS"] ??= "1";
+process.env["ASTRO_ALLOW_FALLBACK"] ??= "true";
 function parseUtc(datetime) {
   const d = new Date(datetime);
   if (Number.isNaN(d.getTime())) {
@@ -1505,6 +2386,9 @@ function parseUtc(datetime) {
   }
   return d;
 }
+function signOf3(lon) {
+  return SIGNS_FR[signIdxOf(lon)] ?? null;
+}
 function formatPlanets(positions) {
   return Object.values(positions).map((p) => ({
     corps: p.key,
@@ -1518,9 +2402,38 @@ function formatPlanets(positions) {
 function jsonResult(value) {
   return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
 }
+var BIRTH_SHAPE = {
+  date: z.string().describe('Date de naissance locale, format YYYY-MM-DD, ex. "1990-05-21".'),
+  time: z.string().describe('Heure de naissance locale, format HH:mm (24 h), ex. "14:30".'),
+  timezone: z.string().describe('Fuseau IANA du lieu de naissance, ex. "Europe/Paris".'),
+  latitude: z.number().min(-90).max(90).describe("Latitude en degr\xE9s d\xE9cimaux (positif = Nord)."),
+  longitude: z.number().min(-180).max(180).describe("Longitude en degr\xE9s d\xE9cimaux (positif = Est).")
+};
+var BODY_ENUM = z.enum([
+  "sun",
+  "moon",
+  "mercury",
+  "venus",
+  "mars",
+  "jupiter",
+  "saturn",
+  "uranus",
+  "neptune",
+  "pluto"
+]);
+var RETRO_BODY_ENUM = z.enum([
+  "mercury",
+  "venus",
+  "mars",
+  "jupiter",
+  "saturn",
+  "uranus",
+  "neptune",
+  "pluto"
+]);
 var server = new McpServer({
   name: "llmastro-ephemeris",
-  version: "0.0.1"
+  version: "0.2.0"
 });
 server.tool(
   "get_planet_positions",
@@ -1529,13 +2442,12 @@ server.tool(
     datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z". Sans fuseau, interpr\xE9t\xE9 en UTC.')
   },
   async ({ datetime }) => {
-    const jd2 = jdFromDate(parseUtc(datetime));
-    const positions = allPositions2(jd2);
+    const jd2 = dateToJd(parseUtc(datetime));
     return jsonResult({
       datetimeUTC: parseUtc(datetime).toISOString(),
       jd: jd2,
       moteur: getActiveEngine(),
-      corps: formatPlanets(positions)
+      corps: formatPlanets(allPositions2(jd2))
     });
   }
 );
@@ -1543,10 +2455,10 @@ server.tool(
   "get_moon_phase",
   "Phase de la Lune (nom, illumination %, description) \xE0 un instant donn\xE9, d\xE9riv\xE9e de la position r\xE9elle Soleil/Lune.",
   {
-    datetime: z.string().describe(`Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z". D\xE9faut d'interpr\xE9tation : UTC.`)
+    datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z".')
   },
   async ({ datetime }) => {
-    const jd2 = jdFromDate(parseUtc(datetime));
+    const jd2 = dateToJd(parseUtc(datetime));
     const mp = moonPhase2(jd2);
     return jsonResult({
       datetimeUTC: parseUtc(datetime).toISOString(),
@@ -1560,76 +2472,347 @@ server.tool(
   }
 );
 server.tool(
-  "get_natal_chart",
-  "Th\xE8me natal complet : positions plan\xE9taires en maisons, aspects, ascendant/MC, phase lunaire. Prend une date/heure LOCALE + fuseau IANA + coordonn\xE9es. Conversion UTC et calcul faits c\xF4t\xE9 serveur.",
+  "get_current_sky",
+  "Le ciel \xE0 l'instant pr\xE9sent (transits du moment) pour un lieu donn\xE9 : positions en maisons + aspects.",
   {
-    date: z.string().describe('Date de naissance locale, format YYYY-MM-DD, ex. "1990-05-21".'),
-    time: z.string().describe('Heure de naissance locale, format HH:mm (24 h), ex. "14:30".'),
-    timezone: z.string().describe('Fuseau IANA du lieu de naissance, ex. "Europe/Paris", "America/New_York".'),
     latitude: z.number().min(-90).max(90).describe("Latitude en degr\xE9s d\xE9cimaux (positif = Nord)."),
     longitude: z.number().min(-180).max(180).describe("Longitude en degr\xE9s d\xE9cimaux (positif = Est).")
   },
-  async ({ date, time, timezone, latitude, longitude }) => {
+  async ({ latitude, longitude }) => {
+    const chart = computeCurrentSky2(latitude, longitude);
+    return jsonResult({
+      instant: (/* @__PURE__ */ new Date()).toISOString(),
+      jd: chart.JD,
+      moteur: getActiveEngine(),
+      retrogrades: chart.retrogrades,
+      phaseLunaire: { phase: chart.moonPhase.phase, illumination: chart.moonPhase.illumination },
+      corps: formatPlanets(chart.planets),
+      aspects: chart.aspects
+    });
+  }
+);
+server.tool(
+  "get_aspects",
+  "Aspects (majeurs et mineurs) entre les plan\xE8tes \xE0 un instant donn\xE9, avec orbe et tonalit\xE9. Grille d'aspects calcul\xE9e par le moteur, pas estim\xE9e.",
+  {
+    datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z".')
+  },
+  async ({ datetime }) => {
+    const jd2 = dateToJd(parseUtc(datetime));
+    return jsonResult({
+      datetimeUTC: parseUtc(datetime).toISOString(),
+      jd: jd2,
+      moteur: getActiveEngine(),
+      aspects: calculateAspects(allPositions2(jd2))
+    });
+  }
+);
+server.tool(
+  "get_natal_chart",
+  "Th\xE8me natal complet : positions en maisons, aspects, ASC/MC, phase lunaire, Lots herm\xE9tiques. Prend une date/heure LOCALE + fuseau IANA + coordonn\xE9es. Zodiaque tropical (d\xE9faut) ou sid\xE9ral (Lahiri), et syst\xE8me de maisons au choix (Placidus par d\xE9faut).",
+  {
+    ...BIRTH_SHAPE,
+    zodiac: z.enum(["tropical", "sidereal"]).optional().describe('Zodiaque : "tropical" (d\xE9faut, occidental) ou "sidereal" (ayanamsa Lahiri).'),
+    houseSystem: z.enum(["placidus", "equal", "whole_sign", "koch", "porphyry", "regiomontanus", "campanus"]).optional().describe('Syst\xE8me de maisons (d\xE9faut "placidus"). Regiomontanus/Campanus/Koch exigent le moteur swisseph ; sinon repli Placidus signal\xE9 par le champ systemeMaisons retourn\xE9.')
+  },
+  async ({ date, time, timezone, latitude, longitude, zodiac, houseSystem }) => {
     const { jdUT, utcISO, offsetMinutes } = localToUTC(date, time, timezone);
-    const chart = computeChartFromJD2(jdUT, latitude, longitude);
+    const opts = {};
+    if (zodiac) opts.zodiac = zodiac;
+    if (houseSystem) opts.houseSystem = houseSystem;
+    const chart = computeChartFromJD2(jdUT, latitude, longitude, opts);
     return jsonResult({
       naissance: { date, time, timezone, latitude, longitude },
       utcISO,
       offsetMinutes,
       jd: jdUT,
       moteur: getActiveEngine(),
-      ascendant: {
-        longitude: Number(chart.houses.asc?.toFixed(4)),
-        signe: SIGNS_FR[Math.floor((chart.houses.asc ?? 0) / 30) % 12] ?? null
-      },
-      milieuDuCiel: {
-        longitude: Number(chart.houses.mc?.toFixed(4)),
-        signe: SIGNS_FR[Math.floor((chart.houses.mc ?? 0) / 30) % 12] ?? null
-      },
-      systemeMaisons: chart.houseSystem,
+      ascendant: { longitude: Number(chart.houses.asc?.toFixed(4)), signe: signOf3(chart.houses.asc ?? 0) },
+      milieuDuCiel: { longitude: Number(chart.houses.mc?.toFixed(4)), signe: signOf3(chart.houses.mc ?? 0) },
+      // systemeMaisons = ce qui a RÉELLEMENT été calculé (chart.houses.system).
+      // Diffère du demandé quand un système swiss-only (koch/regiomontanus/
+      // campanus) retombe sur Placidus en mode AstraCore — honnêteté explicite.
+      systemeMaisons: chart.houses.system,
+      systemeMaisonsDemande: chart.houseSystem,
       zodiaque: chart.zodiac,
+      ayanamsa: chart.ayanamsa,
       phaseLunaire: { phase: chart.moonPhase.phase, illumination: chart.moonPhase.illumination },
       retrogrades: chart.retrogrades,
       corps: formatPlanets(chart.planets),
-      aspects: chart.aspects
+      aspects: chart.aspects,
+      lotsHermetiques: chart.lots
     });
   }
 );
 server.tool(
-  "get_current_sky",
-  "Le ciel \xE0 l'instant pr\xE9sent (transits du moment) pour un lieu donn\xE9 : positions en maisons + aspects.",
+  "get_transits",
+  "Transits crois\xE9s au th\xE8me natal : aspects entre les plan\xE8tes qui transitent (aujourd'hui ou \xE0 une date donn\xE9e) et les plan\xE8tes de naissance, tri\xE9s par orbe. Le c\u0153ur des \xAB pr\xE9visions \xBB.",
   {
-    latitude: z.number().min(-90).max(90).describe("Latitude en degr\xE9s d\xE9cimaux (positif = Nord)."),
-    longitude: z.number().min(-180).max(180).describe("Longitude en degr\xE9s d\xE9cimaux (positif = Est).")
+    ...BIRTH_SHAPE,
+    datetime: z.string().optional().describe('Instant du transit en ISO UTC (d\xE9faut : maintenant), ex. "2026-07-19T09:00:00Z".')
   },
-  async ({ latitude, longitude }) => {
-    const chart = computeCurrentSky2(latitude, longitude);
+  async ({ date, time, timezone, latitude, longitude, datetime }) => {
+    const { jdUT: natalJd } = localToUTC(date, time, timezone);
+    const natal = computeChartFromJD2(natalJd, latitude, longitude).planets;
+    const transitDate = datetime ? parseUtc(datetime) : /* @__PURE__ */ new Date();
+    const transit = allPositions2(dateToJd(transitDate));
+    const aspects = crossAspects(transit, natal);
     return jsonResult({
-      instant: (/* @__PURE__ */ new Date()).toISOString(),
-      jd: chart.JD,
+      naissance: { date, time, timezone },
+      instantTransit: transitDate.toISOString(),
       moteur: getActiveEngine(),
-      retrogrades: chart.retrogrades,
-      phaseLunaire: { phase: chart.moonPhase.phase, illumination: chart.moonPhase.illumination },
+      nbAspects: aspects.length,
+      aspects: aspects.map((a) => ({
+        planeteTransit: a.a,
+        aspect: a.typeFr,
+        symbole: a.symbol,
+        planeteNatale: a.b,
+        orbe: a.orb,
+        exact: a.exact
+      }))
+    });
+  }
+);
+server.tool(
+  "get_synastry",
+  "Synastrie : aspects inter-th\xE8mes entre deux personnes (plan\xE8tes A \xD7 plan\xE8tes B), tri\xE9s par orbe, avec un r\xE9sum\xE9 harmonie/tension. R\xE9utilise la table d'aspects canonique du moteur.",
+  {
+    personA: z.object(BIRTH_SHAPE).describe("Naissance de la personne A."),
+    personB: z.object(BIRTH_SHAPE).describe("Naissance de la personne B.")
+  },
+  async ({ personA, personB }) => {
+    const a = computeChartFromJD2(localToUTC(personA.date, personA.time, personA.timezone).jdUT, personA.latitude, personA.longitude).planets;
+    const b = computeChartFromJD2(localToUTC(personB.date, personB.time, personB.timezone).jdUT, personB.latitude, personB.longitude).planets;
+    const aspects = crossAspects(a, b);
+    return jsonResult({
+      moteur: getActiveEngine(),
+      resume: toneSummary(aspects),
+      aspects: aspects.map((x) => ({
+        planeteA: x.a,
+        aspect: x.typeFr,
+        symbole: x.symbol,
+        tonalite: x.tone,
+        planeteB: x.b,
+        orbe: x.orb,
+        exact: x.exact
+      }))
+    });
+  }
+);
+server.tool(
+  "get_composite_chart",
+  "Th\xE8me composite par mi-points : pour chaque corps, le point milieu circulaire entre les deux th\xE8mes (convention Robert Hand). Repr\xE9sente la relation elle-m\xEAme.",
+  {
+    personA: z.object(BIRTH_SHAPE).describe("Naissance de la personne A."),
+    personB: z.object(BIRTH_SHAPE).describe("Naissance de la personne B.")
+  },
+  async ({ personA, personB }) => {
+    const a = computeChartFromJD2(localToUTC(personA.date, personA.time, personA.timezone).jdUT, personA.latitude, personA.longitude).planets;
+    const b = computeChartFromJD2(localToUTC(personB.date, personB.time, personB.timezone).jdUT, personB.latitude, personB.longitude).planets;
+    return jsonResult({
+      moteur: getActiveEngine(),
+      corpsComposite: compositePositions(a, b).map((c) => ({
+        corps: c.corps,
+        longitude: c.longitude,
+        signe: SIGNS_FR[c.signIdx] ?? null
+      }))
+    });
+  }
+);
+server.tool(
+  "get_secondary_progressions",
+  "Progressions secondaires (m\xE9thode \xAB un jour apr\xE8s la naissance = une ann\xE9e de vie \xBB) : positions plan\xE9taires progress\xE9es \xE0 une date cible. La Lune progress\xE9e (~1 signe / 2,5 ans) est la plus lue.",
+  {
+    ...BIRTH_SHAPE,
+    targetDate: z.string().describe("Date pour laquelle progresser le th\xE8me, format YYYY-MM-DD.")
+  },
+  async ({ date, time, timezone, latitude, longitude, targetDate }) => {
+    const { jdUT: natalJd } = localToUTC(date, time, timezone);
+    const targetJd = dateToJd(parseUtc(targetDate + "T00:00:00Z"));
+    const ageYears = (targetJd - natalJd) / JULIAN_YEAR;
+    const progressedJd = natalJd + ageYears;
+    const prog = allPositions2(progressedJd);
+    return jsonResult({
+      naissance: { date, time, timezone, latitude, longitude },
+      dateCible: targetDate,
+      ageAnnees: Number(ageYears.toFixed(2)),
+      jdProgresse: progressedJd,
+      moteur: getActiveEngine(),
+      note: "Positions progress\xE9es (jour = an). Les maisons progress\xE9es ne sont pas incluses (m\xE9thode variable selon l'\xE9cole).",
+      corpsProgresses: formatPlanets(prog)
+    });
+  }
+);
+server.tool(
+  "get_solar_return",
+  "Retour solaire d'une ann\xE9e donn\xE9e : l'instant exact o\xF9 le Soleil retrouve sa longitude natale, et le th\xE8me dress\xE9 \xE0 cet instant (pour le lieu de r\xE9sidence si fourni, sinon lieu de naissance).",
+  {
+    ...BIRTH_SHAPE,
+    year: z.number().int().describe("Ann\xE9e du retour solaire, ex. 2026."),
+    returnLatitude: z.number().min(-90).max(90).optional().describe("Latitude du lieu au moment du retour (d\xE9faut : lieu de naissance)."),
+    returnLongitude: z.number().min(-180).max(180).optional().describe("Longitude du lieu au moment du retour (d\xE9faut : lieu de naissance).")
+  },
+  async ({ date, time, timezone, latitude, longitude, year, returnLatitude, returnLongitude }) => {
+    const { jdUT: natalJd } = localToUTC(date, time, timezone);
+    const natalSun = bodyLongitude("sun", natalJd);
+    if (natalSun == null) throw new Error("Soleil natal introuvable (moteur).");
+    const natalYear = Number(date.slice(0, 4));
+    const approx = natalJd + (year - natalYear) * JULIAN_YEAR;
+    const returnJd = findLongitudeReturn("sun", natalSun, approx - 5, approx + 5, 0.5);
+    if (returnJd == null) throw new Error(`Retour solaire ${year} introuvable dans la fen\xEAtre calcul\xE9e.`);
+    const lat = returnLatitude ?? latitude;
+    const lng = returnLongitude ?? longitude;
+    const chart = computeChartFromJD2(returnJd, lat, lng);
+    return jsonResult({
+      naissance: { date, time, timezone },
+      annee: year,
+      lieuRetour: { latitude: lat, longitude: lng },
+      instantRetourUTC: jdToDate(returnJd).toISOString(),
+      jd: returnJd,
+      moteur: getActiveEngine(),
+      ascendant: { longitude: Number(chart.houses.asc?.toFixed(4)), signe: signOf3(chart.houses.asc ?? 0) },
+      milieuDuCiel: { longitude: Number(chart.houses.mc?.toFixed(4)), signe: signOf3(chart.houses.mc ?? 0) },
       corps: formatPlanets(chart.planets),
       aspects: chart.aspects
     });
   }
 );
+server.tool(
+  "get_lunar_return",
+  "Retour lunaire : le prochain instant, apr\xE8s une date de r\xE9f\xE9rence, o\xF9 la Lune retrouve sa longitude natale (~tous les 27,3 jours), et le th\xE8me \xE0 cet instant.",
+  {
+    ...BIRTH_SHAPE,
+    after: z.string().optional().describe("Chercher le retour apr\xE8s cet instant ISO UTC (d\xE9faut : maintenant).")
+  },
+  async ({ date, time, timezone, latitude, longitude, after }) => {
+    const { jdUT: natalJd } = localToUTC(date, time, timezone);
+    const natalMoon = bodyLongitude("moon", natalJd);
+    if (natalMoon == null) throw new Error("Lune natale introuvable (moteur).");
+    const fromJd = dateToJd(after ? parseUtc(after) : /* @__PURE__ */ new Date());
+    const returnJd = findLongitudeReturn("moon", natalMoon, fromJd, fromJd + 30, 0.25);
+    if (returnJd == null) throw new Error("Retour lunaire introuvable dans les 30 jours.");
+    const chart = computeChartFromJD2(returnJd, latitude, longitude);
+    return jsonResult({
+      naissance: { date, time, timezone },
+      apres: jdToDate(fromJd).toISOString(),
+      instantRetourUTC: jdToDate(returnJd).toISOString(),
+      jd: returnJd,
+      moteur: getActiveEngine(),
+      ascendant: { longitude: Number(chart.houses.asc?.toFixed(4)), signe: signOf3(chart.houses.asc ?? 0) },
+      corps: formatPlanets(chart.planets)
+    });
+  }
+);
+server.tool(
+  "get_ingresses",
+  "Ingr\xE8s : dates auxquelles un corps change de signe sur une plage donn\xE9e (entr\xE9es/sorties de signe), robuste aux passages r\xE9trogrades.",
+  {
+    body: BODY_ENUM.describe("Corps \xE0 suivre."),
+    start: z.string().describe('D\xE9but de la plage, ISO UTC, ex. "2026-01-01T00:00:00Z".'),
+    end: z.string().describe("Fin de la plage, ISO UTC. Plage max conseill\xE9e : quelques ann\xE9es.")
+  },
+  async ({ body, start, end }) => {
+    const j0 = dateToJd(parseUtc(start));
+    const j1 = dateToJd(parseUtc(end));
+    if (j1 <= j0) throw new Error("`end` doit \xEAtre post\xE9rieur \xE0 `start`.");
+    const step = body === "moon" ? 0.25 : 1;
+    const events = findIngresses(body, j0, j1, step);
+    return jsonResult({
+      corps: body,
+      plage: { start: parseUtc(start).toISOString(), end: parseUtc(end).toISOString() },
+      moteur: getActiveEngine(),
+      nbIngres: events.length,
+      ingres: events.map((e) => ({
+        dateUTC: jdToDate(e.jd).toISOString(),
+        deSigne: SIGNS_FR[e.deSigneIdx] ?? null,
+        versSigne: SIGNS_FR[e.versSigneIdx] ?? null
+      }))
+    });
+  }
+);
+server.tool(
+  "get_retrograde_windows",
+  "Stations de r\xE9trogradation : dates auxquelles un corps change de direction (station r\xE9trograde ou directe) sur une plage donn\xE9e. Le Soleil et la Lune ne r\xE9trogradent jamais.",
+  {
+    body: RETRO_BODY_ENUM.describe("Corps \xE0 suivre (Mercure\u2192Pluton)."),
+    start: z.string().describe("D\xE9but de la plage, ISO UTC."),
+    end: z.string().describe("Fin de la plage, ISO UTC.")
+  },
+  async ({ body, start, end }) => {
+    const j0 = dateToJd(parseUtc(start));
+    const j1 = dateToJd(parseUtc(end));
+    if (j1 <= j0) throw new Error("`end` doit \xEAtre post\xE9rieur \xE0 `start`.");
+    const stations = findRetrogradeStations(body, j0, j1, 0.5);
+    return jsonResult({
+      corps: body,
+      plage: { start: parseUtc(start).toISOString(), end: parseUtc(end).toISOString() },
+      moteur: getActiveEngine(),
+      nbStations: stations.length,
+      stations: stations.map((s) => ({
+        dateUTC: jdToDate(s.jd).toISOString(),
+        station: s.station === "retrograde" ? "r\xE9trograde" : "directe"
+      }))
+    });
+  }
+);
+server.tool(
+  "get_eclipse_details",
+  "D\xE9tail d'une \xE9clipse (magnitude, obscuration, type, s\xE9rie de Saros) pour une date d'\xE9clipse connue. N\xE9cessite le moteur swisseph (retourne null en mode AstraCore).",
+  {
+    datetime: z.string().describe(`Instant de l'\xE9clipse en ISO UTC, ex. "2026-08-12T17:46:00Z".`),
+    kind: z.enum(["solar", "lunar"]).describe("Type d'\xE9clipse \xE0 d\xE9tailler.")
+  },
+  async ({ datetime, kind }) => {
+    const jd2 = dateToJd(parseUtc(datetime));
+    const details = kind === "solar" ? computeSolarEclipseDetailsSwiss(jd2) : computeLunarEclipseDetailsSwiss(jd2);
+    return jsonResult({
+      datetimeUTC: parseUtc(datetime).toISOString(),
+      jd: jd2,
+      moteur: getActiveEngine(),
+      type: kind,
+      details,
+      note: details == null ? "D\xE9tail indisponible : moteur AstraCore actif (swisseph requis) ou date sans \xE9clipse. Passe en ASTRO_ENGINE=swisseph." : void 0
+    });
+  }
+);
+server.tool(
+  "get_next_eclipse",
+  "Trouve la prochaine (ou pr\xE9c\xE9dente) \xE9clipse solaire ou lunaire \xE0 partir d'une date : instant du maximum, type, et fen\xEAtres de contact. N\xE9cessite le moteur swisseph (retourne null en AstraCore).",
+  {
+    from: z.string().describe('Chercher \xE0 partir de cet instant ISO UTC, ex. "2026-01-01T00:00:00Z".'),
+    kind: z.enum(["solar", "lunar"]).describe("Type d'\xE9clipse \xE0 chercher."),
+    backward: z.boolean().optional().describe("true = chercher la pr\xE9c\xE9dente au lieu de la prochaine (d\xE9faut false).")
+  },
+  async ({ from, kind, backward }) => {
+    const jd2 = dateToJd(parseUtc(from));
+    const back = backward ?? false;
+    const ecl = kind === "solar" ? findNextSolarEclipseSwiss(jd2, back) : findNextLunarEclipseSwiss(jd2, back);
+    return jsonResult({
+      depuis: parseUtc(from).toISOString(),
+      sens: back ? "pr\xE9c\xE9dente" : "prochaine",
+      type: kind,
+      moteur: getActiveEngine(),
+      eclipse: ecl == null ? null : {
+        ...ecl,
+        maximumUTC: jdToDate(ecl.jdMaximum).toISOString()
+      },
+      note: ecl == null ? "Recherche indisponible : moteur AstraCore actif (swisseph requis). Passe en ASTRO_ENGINE=swisseph." : void 0
+    });
+  }
+);
 server.tool(
   "get_astrocartography",
-  "Astrocartographie \xE0 un instant donn\xE9 : pour chaque corps, les m\xE9ridiens MC/IC et les courbes lever/coucher, plus les parans (croisements de lignes). Utile pour \xAB o\xF9 telle plan\xE8te est-elle forte \xBB.",
+  "Astrocartographie \xE0 un instant donn\xE9 : pour chaque corps, les m\xE9ridiens MC/IC et le nombre de points des courbes lever/coucher, plus les parans (croisements de lignes).",
   {
-    datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z". Sans fuseau, interpr\xE9t\xE9 en UTC.')
+    datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-18T14:00:00Z".')
   },
   async ({ datetime }) => {
-    const jd2 = jdFromDate(parseUtc(datetime));
+    const jd2 = dateToJd(parseUtc(datetime));
     const acg = computeAstrocartography(jd2);
     return jsonResult({
       datetimeUTC: parseUtc(datetime).toISOString(),
       jd: jd2,
       moteur: getActiveEngine(),
-      // Résumé lisible : on omet les tableaux de points (courbes échantillonnées),
-      // on garde les méridiens et le nombre de points par courbe.
       lignes: acg.lines.map((l) => ({
         corps: l.key,
         meridienMC: Number(l.mcLng?.toFixed(4)),
@@ -1648,58 +2831,22 @@ server.tool(
     });
   }
 );
-var NOISE_KEYS = /* @__PURE__ */ new Set(["fortune", "southNode", "ceres", "pallas", "juno", "vesta", "lilithTrue"]);
-function crossAspects(transit, natal) {
-  const out = [];
-  for (const [tk, tp] of Object.entries(transit)) {
-    if (NOISE_KEYS.has(tk)) continue;
-    for (const [nk, np] of Object.entries(natal)) {
-      if (NOISE_KEYS.has(nk)) continue;
-      let d = Math.abs(tp.longitude - np.longitude);
-      if (d > 180) d = 360 - d;
-      for (const a of ASPECT_TYPES) {
-        const isLum = tk === "sun" || tk === "moon" || nk === "sun" || nk === "moon";
-        const maxOrb = a.orb + (isLum ? 2 : 0);
-        const o = Math.abs(d - a.angle);
-        if (o <= maxOrb) {
-          out.push({
-            planeteTransit: tk,
-            aspect: a.nameFr,
-            symbole: a.symbol,
-            planeteNatale: nk,
-            orbe: Number(o.toFixed(2)),
-            exact: o < 1
-          });
-        }
-      }
-    }
-  }
-  return out.sort((x, y) => x.orbe - y.orbe);
-}
 server.tool(
-  "get_transits",
-  "Transits du moment crois\xE9s au th\xE8me natal : aspects entre les plan\xE8tes qui transitent aujourd'hui (ou \xE0 une date donn\xE9e) et les plan\xE8tes de naissance. Le c\u0153ur des \xAB pr\xE9visions \xBB.",
+  "get_life_path",
+  "Nombre du chemin de vie (num\xE9rologie pythagoricienne) calcul\xE9 depuis la date de naissance locale. Fait d\xE9terministe, jamais estim\xE9 par le mod\xE8le.",
   {
-    date: z.string().describe("Date de naissance locale, YYYY-MM-DD."),
-    time: z.string().describe("Heure de naissance locale, HH:mm."),
-    timezone: z.string().describe('Fuseau IANA du lieu de naissance, ex. "Europe/Paris".'),
-    latitude: z.number().min(-90).max(90).describe("Latitude de naissance (deg d\xE9cimaux)."),
-    longitude: z.number().min(-180).max(180).describe("Longitude de naissance (deg d\xE9cimaux)."),
-    datetime: z.string().optional().describe('Instant du transit en ISO UTC (d\xE9faut : maintenant), ex. "2026-07-19T09:00:00Z".')
+    date: z.string().describe("Date de naissance locale, format YYYY-MM-DD.")
   },
-  async ({ date, time, timezone, latitude, longitude, datetime }) => {
-    const { jdUT: natalJd } = localToUTC(date, time, timezone);
-    const natal = computeChartFromJD2(natalJd, latitude, longitude).planets;
-    const transitDate = datetime ? parseUtc(datetime) : /* @__PURE__ */ new Date();
-    const transit = allPositions2(jdFromDate(transitDate));
-    const aspects = crossAspects(transit, natal);
-    return jsonResult({
-      naissance: { date, time, timezone },
-      instantTransit: transitDate.toISOString(),
-      moteur: getActiveEngine(),
-      nbAspects: aspects.length,
-      aspects
-    });
+  async ({ date }) => {
+    return jsonResult({ date, cheminDeVie: computeLifePath(date) });
+  }
+);
+server.tool(
+  "get_engine_diagnostic",
+  "Diagnostic du moteur de calcul : quel moteur est actif (swisseph sub-arcseconde vs AstraCore), si l'addon natif a charg\xE9, et pourquoi. Utile pour v\xE9rifier la pr\xE9cision dont vous b\xE9n\xE9ficiez.",
+  {},
+  async () => {
+    return jsonResult({ moteur: getActiveEngine(), diagnostic: getEngineDiagnostic() });
   }
 );
 var HORIZONS_API = "https://ssd.jpl.nasa.gov/api/horizons.api";
@@ -1758,10 +2905,10 @@ server.tool(
   "Preuve d'exactitude : compare nos positions plan\xE9taires \xE0 la r\xE9f\xE9rence mondiale JPL Horizons (NASA) au m\xEAme instant, et donne l'\xE9cart en secondes d'arc. N\xE9cessite un acc\xE8s r\xE9seau.",
   {
     datetime: z.string().describe('Instant en ISO 8601 UTC, ex. "2026-07-19T00:00:00Z".'),
-    bodies: z.array(z.enum(["sun", "moon", "mercury", "venus", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"])).optional().describe("Sous-ensemble de corps \xE0 valider (d\xE9faut : les 10 classiques).")
+    bodies: z.array(BODY_ENUM).optional().describe("Sous-ensemble de corps \xE0 valider (d\xE9faut : les 10 classiques).")
   },
   async ({ datetime, bodies }) => {
-    const jd2 = jdFromDate(parseUtc(datetime));
+    const jd2 = dateToJd(parseUtc(datetime));
     const ours = allPositions2(jd2);
     const keys = bodies ?? Object.keys(HORIZONS_CMD);
     const rows = await Promise.all(