caelus-mcp 0.13.0 → 0.14.0

package/README.md

@@ -1,10 +1,11 @@
 # caelus-mcp
 
 MCP server for the [caelus](https://github.com/heavyblotto/caelus) ephemeris
-engine: eighteen chart tools over stdio. Computation only — positions, houses,
+engine: twenty-two chart tools over stdio. Computation only — positions, houses,
 aspects with orbs, event search, electional, returns, progressions, composite,
 dignities, Hermetic lots, the Hellenistic time-lords (profections, firdaria,
-zodiacal releasing), and primary directions — the model does the interpreting.
+zodiacal releasing), primary directions, and the Vedic layer (nakshatras,
+dashas, vargas, yogas) — the model does the interpreting.
 It needs
 no API keys, ephemeris files, or network calls; the engine data ships inside
 the package.
@@ -55,7 +56,11 @@ A hosted Streamable HTTP endpoint is also live at
 | `profections` | Annual and monthly profections to a target date: age, the profected signs and their whole-sign houses, and the lord of the year |
 | `firdaria` | The firdaria planetary time-lord periods: the full 75-year timeline (nine periods, seven sub-periods each) and the lords active at a target date |
 | `releasing` | Zodiacal releasing (aphesis) from the Lot of Spirit or Fortune: the L1–L4 period timeline and the lords active at a target date, with loosing of the bond |
-| `directions` | Primary directions of the seven traditional planets to the four angles (MC/IC/Asc/Desc) by the Naibod or Ptolemy time key, sorted by age |
+| `directions` | Primary directions of the seven traditional planets to the four angles (MC/IC/Asc/Desc), and optionally between the planets (mundane), by the Naibod or Ptolemy time key, sorted by age |
+| `nakshatras` | The nakshatra (lunar mansion), pada, and ruling planet of each classical planet and the Ascendant on the sidereal zodiac (Lahiri by default) |
+| `dasha` | Vedic dasha periods from the Moon's nakshatra — Vimshottari (120y), Yogini (36y), or Ashtottari (108y): the maha → antar timeline and the lords active at a target date |
+| `vargas` | Parashari divisional charts (D1 rasi, D2, D3, D9 navamsa, D10, D12, D30): the divisional sign of each planet and the Ascendant |
+| `yogas` | Vedic yogas on the rasi chart: Pancha Mahapurusha, Gajakesari, Budha-Aditya, Chandra-Mangala, Kemadruma, plus raja/dhana yogas and yogakarakas |
 
 `natal_chart` and `current_sky` also tag each body with its solar phase
 (cazimi/combust/under-the-beams) and each aspect with applying/separating.

package/dist/src/server.d.ts

@@ -3,7 +3,7 @@
  * caelus-mcp -- MCP server for the caelus ephemeris engine.
  *
  * Design (per 2026 MCP practice): one bounded context (chart computation),
- * a small curated tool surface (eighteen outcome-level tools, not API wrappers),
+ * a small curated tool surface (twenty-two outcome-level tools, not API wrappers),
  * and token-frugal outputs (positions to 0.01 deg, terse keys, no prose --
  * the model does the interpreting, the server does the math).
  *
@@ -1591,6 +1591,25 @@ export declare const directionsOut: z.ZodObject<{
         angle: "MC" | "IC" | "ASC" | "DSC";
         arc: number;
     }>, "many">;
+    mundane: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        promissor: z.ZodString;
+        significator: z.ZodString;
+        arc: z.ZodNumber;
+        years: z.ZodNumber;
+        date: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        date: string;
+        years: number;
+        arc: number;
+        promissor: string;
+        significator: string;
+    }, {
+        date: string;
+        years: number;
+        arc: number;
+        promissor: string;
+        significator: string;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     natal_utc: string;
     key: "ptolemy" | "naibod";
@@ -1601,6 +1620,13 @@ export declare const directionsOut: z.ZodObject<{
         angle: "MC" | "IC" | "ASC" | "DSC";
         arc: number;
     }[];
+    mundane?: {
+        date: string;
+        years: number;
+        arc: number;
+        promissor: string;
+        significator: string;
+    }[] | undefined;
 }, {
     natal_utc: string;
     key: "ptolemy" | "naibod";
@@ -1611,6 +1637,272 @@ export declare const directionsOut: z.ZodObject<{
         angle: "MC" | "IC" | "ASC" | "DSC";
         arc: number;
     }[];
+    mundane?: {
+        date: string;
+        years: number;
+        arc: number;
+        promissor: string;
+        significator: string;
+    }[] | undefined;
+}>;
+export declare const nakshatrasOut: z.ZodObject<{
+    natal_utc: z.ZodString;
+    zodiac: z.ZodEnum<["tropical", "sidereal:lahiri", "sidereal:fagan_bradley", "sidereal:krishnamurti", "sidereal:raman", "sidereal:yukteshwar", "sidereal:galcent_0sag", "sidereal:true_citra"]>;
+    points: z.ZodRecord<z.ZodString, z.ZodObject<{
+        nakshatra: z.ZodString;
+        pada: z.ZodNumber;
+        lord: z.ZodString;
+        deg: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        deg: number;
+        lord: string;
+        nakshatra: string;
+        pada: number;
+    }, {
+        deg: number;
+        lord: string;
+        nakshatra: string;
+        pada: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+    natal_utc: string;
+    points: Record<string, {
+        deg: number;
+        lord: string;
+        nakshatra: string;
+        pada: number;
+    }>;
+}, {
+    zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+    natal_utc: string;
+    points: Record<string, {
+        deg: number;
+        lord: string;
+        nakshatra: string;
+        pada: number;
+    }>;
+}>;
+export declare const dashaOut: z.ZodObject<{
+    natal_utc: z.ZodString;
+    system: z.ZodEnum<["vimshottari", "yogini", "ashtottari"]>;
+    moon_nakshatra: z.ZodString;
+    start_lord: z.ZodOptional<z.ZodString>;
+    start_yogini: z.ZodOptional<z.ZodString>;
+    balance_years: z.ZodNumber;
+    periods: z.ZodArray<z.ZodObject<{
+        lord: z.ZodOptional<z.ZodString>;
+        yogini: z.ZodOptional<z.ZodString>;
+        start: z.ZodString;
+        end: z.ZodString;
+        sub: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            lord: z.ZodOptional<z.ZodString>;
+            yogini: z.ZodOptional<z.ZodString>;
+            start: z.ZodString;
+            end: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            yogini?: string | undefined;
+        }, {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            yogini?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+        lord?: string | undefined;
+        sub?: {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            yogini?: string | undefined;
+        }[] | undefined;
+        yogini?: string | undefined;
+    }, {
+        start: string;
+        end: string;
+        lord?: string | undefined;
+        sub?: {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            yogini?: string | undefined;
+        }[] | undefined;
+        yogini?: string | undefined;
+    }>, "many">;
+    active: z.ZodOptional<z.ZodObject<{
+        target_utc: z.ZodString;
+        maha: z.ZodNullable<z.ZodString>;
+        antar: z.ZodNullable<z.ZodString>;
+        pratyantar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        target_utc: string;
+        maha: string | null;
+        antar: string | null;
+        pratyantar?: string | null | undefined;
+    }, {
+        target_utc: string;
+        maha: string | null;
+        antar: string | null;
+        pratyantar?: string | null | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    natal_utc: string;
+    periods: {
+        start: string;
+        end: string;
+        lord?: string | undefined;
+        sub?: {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            yogini?: string | undefined;
+        }[] | undefined;
+        yogini?: string | undefined;
+    }[];
+    system: "yogini" | "vimshottari" | "ashtottari";
+    moon_nakshatra: string;
+    balance_years: number;
+    active?: {
+        target_utc: string;
+        maha: string | null;
+        antar: string | null;
+        pratyantar?: string | null | undefined;
+    } | undefined;
+    start_lord?: string | undefined;
+    start_yogini?: string | undefined;
+}, {
+    natal_utc: string;
+    periods: {
+        start: string;
+        end: string;
+        lord?: string | undefined;
+        sub?: {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            yogini?: string | undefined;
+        }[] | undefined;
+        yogini?: string | undefined;
+    }[];
+    system: "yogini" | "vimshottari" | "ashtottari";
+    moon_nakshatra: string;
+    balance_years: number;
+    active?: {
+        target_utc: string;
+        maha: string | null;
+        antar: string | null;
+        pratyantar?: string | null | undefined;
+    } | undefined;
+    start_lord?: string | undefined;
+    start_yogini?: string | undefined;
+}>;
+export declare const vargasOut: z.ZodObject<{
+    natal_utc: z.ZodString;
+    zodiac: z.ZodEnum<["tropical", "sidereal:lahiri", "sidereal:fagan_bradley", "sidereal:krishnamurti", "sidereal:raman", "sidereal:yukteshwar", "sidereal:galcent_0sag", "sidereal:true_citra"]>;
+    charts: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        sign: z.ZodString;
+        sign_index: z.ZodNumber;
+        division: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        sign: string;
+        sign_index: number;
+        division: number;
+    }, {
+        sign: string;
+        sign_index: number;
+        division: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+    natal_utc: string;
+    charts: Record<string, Record<string, {
+        sign: string;
+        sign_index: number;
+        division: number;
+    }>>;
+}, {
+    zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+    natal_utc: string;
+    charts: Record<string, Record<string, {
+        sign: string;
+        sign_index: number;
+        division: number;
+    }>>;
+}>;
+export declare const yogasOut: z.ZodObject<{
+    natal_utc: z.ZodString;
+    zodiac: z.ZodEnum<["tropical", "sidereal:lahiri", "sidereal:fagan_bradley", "sidereal:krishnamurti", "sidereal:raman", "sidereal:yukteshwar", "sidereal:galcent_0sag", "sidereal:true_citra"]>;
+    yogas: z.ZodArray<z.ZodObject<{
+        yoga: z.ZodString;
+        planets: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        yoga: string;
+        planets: string[];
+    }, {
+        yoga: string;
+        planets: string[];
+    }>, "many">;
+    kemadruma: z.ZodBoolean;
+    raja_yogas: z.ZodArray<z.ZodObject<{
+        lords: z.ZodArray<z.ZodString, "many">;
+        via: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        lords: string[];
+        via: string;
+    }, {
+        lords: string[];
+        via: string;
+    }>, "many">;
+    dhana_yogas: z.ZodArray<z.ZodObject<{
+        lords: z.ZodArray<z.ZodString, "many">;
+        via: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        lords: string[];
+        via: string;
+    }, {
+        lords: string[];
+        via: string;
+    }>, "many">;
+    yogakarakas: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+    natal_utc: string;
+    yogas: {
+        yoga: string;
+        planets: string[];
+    }[];
+    kemadruma: boolean;
+    raja_yogas: {
+        lords: string[];
+        via: string;
+    }[];
+    dhana_yogas: {
+        lords: string[];
+        via: string;
+    }[];
+    yogakarakas: string[];
+}, {
+    zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+    natal_utc: string;
+    yogas: {
+        yoga: string;
+        planets: string[];
+    }[];
+    kemadruma: boolean;
+    raja_yogas: {
+        lords: string[];
+        via: string;
+    }[];
+    dhana_yogas: {
+        lords: string[];
+        via: string;
+    }[];
+    yogakarakas: string[];
 }>;
 export declare const OUTPUT_SCHEMAS: {
     readonly natal_chart: z.ZodObject<{
@@ -3312,6 +3604,25 @@ export declare const OUTPUT_SCHEMAS: {
             angle: "MC" | "IC" | "ASC" | "DSC";
             arc: number;
         }>, "many">;
+        mundane: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            promissor: z.ZodString;
+            significator: z.ZodString;
+            arc: z.ZodNumber;
+            years: z.ZodNumber;
+            date: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            date: string;
+            years: number;
+            arc: number;
+            promissor: string;
+            significator: string;
+        }, {
+            date: string;
+            years: number;
+            arc: number;
+            promissor: string;
+            significator: string;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         natal_utc: string;
         key: "ptolemy" | "naibod";
@@ -3322,6 +3633,13 @@ export declare const OUTPUT_SCHEMAS: {
             angle: "MC" | "IC" | "ASC" | "DSC";
             arc: number;
         }[];
+        mundane?: {
+            date: string;
+            years: number;
+            arc: number;
+            promissor: string;
+            significator: string;
+        }[] | undefined;
     }, {
         natal_utc: string;
         key: "ptolemy" | "naibod";
@@ -3332,6 +3650,272 @@ export declare const OUTPUT_SCHEMAS: {
             angle: "MC" | "IC" | "ASC" | "DSC";
             arc: number;
         }[];
+        mundane?: {
+            date: string;
+            years: number;
+            arc: number;
+            promissor: string;
+            significator: string;
+        }[] | undefined;
+    }>;
+    readonly nakshatras: z.ZodObject<{
+        natal_utc: z.ZodString;
+        zodiac: z.ZodEnum<["tropical", "sidereal:lahiri", "sidereal:fagan_bradley", "sidereal:krishnamurti", "sidereal:raman", "sidereal:yukteshwar", "sidereal:galcent_0sag", "sidereal:true_citra"]>;
+        points: z.ZodRecord<z.ZodString, z.ZodObject<{
+            nakshatra: z.ZodString;
+            pada: z.ZodNumber;
+            lord: z.ZodString;
+            deg: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            deg: number;
+            lord: string;
+            nakshatra: string;
+            pada: number;
+        }, {
+            deg: number;
+            lord: string;
+            nakshatra: string;
+            pada: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+        natal_utc: string;
+        points: Record<string, {
+            deg: number;
+            lord: string;
+            nakshatra: string;
+            pada: number;
+        }>;
+    }, {
+        zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+        natal_utc: string;
+        points: Record<string, {
+            deg: number;
+            lord: string;
+            nakshatra: string;
+            pada: number;
+        }>;
+    }>;
+    readonly dasha: z.ZodObject<{
+        natal_utc: z.ZodString;
+        system: z.ZodEnum<["vimshottari", "yogini", "ashtottari"]>;
+        moon_nakshatra: z.ZodString;
+        start_lord: z.ZodOptional<z.ZodString>;
+        start_yogini: z.ZodOptional<z.ZodString>;
+        balance_years: z.ZodNumber;
+        periods: z.ZodArray<z.ZodObject<{
+            lord: z.ZodOptional<z.ZodString>;
+            yogini: z.ZodOptional<z.ZodString>;
+            start: z.ZodString;
+            end: z.ZodString;
+            sub: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                lord: z.ZodOptional<z.ZodString>;
+                yogini: z.ZodOptional<z.ZodString>;
+                start: z.ZodString;
+                end: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                start: string;
+                end: string;
+                lord?: string | undefined;
+                yogini?: string | undefined;
+            }, {
+                start: string;
+                end: string;
+                lord?: string | undefined;
+                yogini?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            sub?: {
+                start: string;
+                end: string;
+                lord?: string | undefined;
+                yogini?: string | undefined;
+            }[] | undefined;
+            yogini?: string | undefined;
+        }, {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            sub?: {
+                start: string;
+                end: string;
+                lord?: string | undefined;
+                yogini?: string | undefined;
+            }[] | undefined;
+            yogini?: string | undefined;
+        }>, "many">;
+        active: z.ZodOptional<z.ZodObject<{
+            target_utc: z.ZodString;
+            maha: z.ZodNullable<z.ZodString>;
+            antar: z.ZodNullable<z.ZodString>;
+            pratyantar: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            target_utc: string;
+            maha: string | null;
+            antar: string | null;
+            pratyantar?: string | null | undefined;
+        }, {
+            target_utc: string;
+            maha: string | null;
+            antar: string | null;
+            pratyantar?: string | null | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        natal_utc: string;
+        periods: {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            sub?: {
+                start: string;
+                end: string;
+                lord?: string | undefined;
+                yogini?: string | undefined;
+            }[] | undefined;
+            yogini?: string | undefined;
+        }[];
+        system: "yogini" | "vimshottari" | "ashtottari";
+        moon_nakshatra: string;
+        balance_years: number;
+        active?: {
+            target_utc: string;
+            maha: string | null;
+            antar: string | null;
+            pratyantar?: string | null | undefined;
+        } | undefined;
+        start_lord?: string | undefined;
+        start_yogini?: string | undefined;
+    }, {
+        natal_utc: string;
+        periods: {
+            start: string;
+            end: string;
+            lord?: string | undefined;
+            sub?: {
+                start: string;
+                end: string;
+                lord?: string | undefined;
+                yogini?: string | undefined;
+            }[] | undefined;
+            yogini?: string | undefined;
+        }[];
+        system: "yogini" | "vimshottari" | "ashtottari";
+        moon_nakshatra: string;
+        balance_years: number;
+        active?: {
+            target_utc: string;
+            maha: string | null;
+            antar: string | null;
+            pratyantar?: string | null | undefined;
+        } | undefined;
+        start_lord?: string | undefined;
+        start_yogini?: string | undefined;
+    }>;
+    readonly vargas: z.ZodObject<{
+        natal_utc: z.ZodString;
+        zodiac: z.ZodEnum<["tropical", "sidereal:lahiri", "sidereal:fagan_bradley", "sidereal:krishnamurti", "sidereal:raman", "sidereal:yukteshwar", "sidereal:galcent_0sag", "sidereal:true_citra"]>;
+        charts: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            sign: z.ZodString;
+            sign_index: z.ZodNumber;
+            division: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            sign: string;
+            sign_index: number;
+            division: number;
+        }, {
+            sign: string;
+            sign_index: number;
+            division: number;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+        natal_utc: string;
+        charts: Record<string, Record<string, {
+            sign: string;
+            sign_index: number;
+            division: number;
+        }>>;
+    }, {
+        zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+        natal_utc: string;
+        charts: Record<string, Record<string, {
+            sign: string;
+            sign_index: number;
+            division: number;
+        }>>;
+    }>;
+    readonly yogas: z.ZodObject<{
+        natal_utc: z.ZodString;
+        zodiac: z.ZodEnum<["tropical", "sidereal:lahiri", "sidereal:fagan_bradley", "sidereal:krishnamurti", "sidereal:raman", "sidereal:yukteshwar", "sidereal:galcent_0sag", "sidereal:true_citra"]>;
+        yogas: z.ZodArray<z.ZodObject<{
+            yoga: z.ZodString;
+            planets: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            yoga: string;
+            planets: string[];
+        }, {
+            yoga: string;
+            planets: string[];
+        }>, "many">;
+        kemadruma: z.ZodBoolean;
+        raja_yogas: z.ZodArray<z.ZodObject<{
+            lords: z.ZodArray<z.ZodString, "many">;
+            via: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            lords: string[];
+            via: string;
+        }, {
+            lords: string[];
+            via: string;
+        }>, "many">;
+        dhana_yogas: z.ZodArray<z.ZodObject<{
+            lords: z.ZodArray<z.ZodString, "many">;
+            via: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            lords: string[];
+            via: string;
+        }, {
+            lords: string[];
+            via: string;
+        }>, "many">;
+        yogakarakas: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+        natal_utc: string;
+        yogas: {
+            yoga: string;
+            planets: string[];
+        }[];
+        kemadruma: boolean;
+        raja_yogas: {
+            lords: string[];
+            via: string;
+        }[];
+        dhana_yogas: {
+            lords: string[];
+            via: string;
+        }[];
+        yogakarakas: string[];
+    }, {
+        zodiac: "tropical" | "sidereal:lahiri" | "sidereal:fagan_bradley" | "sidereal:krishnamurti" | "sidereal:raman" | "sidereal:yukteshwar" | "sidereal:galcent_0sag" | "sidereal:true_citra";
+        natal_utc: string;
+        yogas: {
+            yoga: string;
+            planets: string[];
+        }[];
+        kemadruma: boolean;
+        raja_yogas: {
+            lords: string[];
+            via: string;
+        }[];
+        dhana_yogas: {
+            lords: string[];
+            via: string;
+        }[];
+        yogakarakas: string[];
     }>;
 };
 export interface BuildServerOptions {

package/dist/src/server.js

@@ -3,7 +3,7 @@
  * caelus-mcp -- MCP server for the caelus ephemeris engine.
  *
  * Design (per 2026 MCP practice): one bounded context (chart computation),
- * a small curated tool surface (eighteen outcome-level tools, not API wrappers),
+ * a small curated tool surface (twenty-two outcome-level tools, not API wrappers),
  * and token-frugal outputs (positions to 0.01 deg, terse keys, no prose --
  * the model does the interpreting, the server does the math).
  *
@@ -17,7 +17,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { realpathSync } from "node:fs";
-import { Engine, BODIES, julianDay, mod, riseSet, crossings, lunarPhases, stations, lunarEclipses, solarEclipses, ASPECTS, DEFAULT_ORBS, SIGNS as SIGN_NAMES, dignities, solarPhase, aspectPhase, planetaryHour, voidOfCourse, CAZIMI_DEG, COMBUST_DEG, UNDER_BEAMS_DEG, solarReturn, lunarReturn, progressedLongitude, directedLongitude, solarArc, progressedJd, compositeLongitudes, davisonParams, midpointLon, dignityOf, isDayChart, planetarySect, inSect, lots, HERMETIC_LOTS, profectionAt, firdaria, firdariaActive, zrRelease, zrActive, lotSpirit, lotFortune, primaryDirections, } from "caelus";
+import { Engine, BODIES, julianDay, mod, riseSet, crossings, lunarPhases, stations, lunarEclipses, solarEclipses, ASPECTS, DEFAULT_ORBS, SIGNS as SIGN_NAMES, dignities, solarPhase, aspectPhase, planetaryHour, voidOfCourse, CAZIMI_DEG, COMBUST_DEG, UNDER_BEAMS_DEG, solarReturn, lunarReturn, progressedLongitude, directedLongitude, solarArc, progressedJd, compositeLongitudes, davisonParams, midpointLon, dignityOf, isDayChart, planetarySect, inSect, lots, HERMETIC_LOTS, profectionAt, firdaria, firdariaActive, zrRelease, zrActive, lotSpirit, lotFortune, primaryDirections, mundaneDirections, nakshatra, vimshottariDashas, vimshottariAt, yoginiDashas, yoginiAt, ashtottariDashas, ashtottariAt, varga, VARGA_DIVISIONS, yogasAt, kemadrumaAt, rajaYogasAt, dhanaYogasAt, } from "caelus";
 import { loadNodeData } from "caelus/node";
 const require = createRequire(import.meta.url);
 // Read our own version relative to this file (dist/src/server.js -> the package
@@ -80,6 +80,10 @@ const ZODIACS = [
 ];
 const zodiacSchema = z.enum(ZODIACS).default("tropical")
     .describe("tropical (default) or sidereal:<ayanamsa>");
+// Jyotish techniques (nakshatras, vargas, dashas, yogas) are sidereal by
+// definition; default these tools to Lahiri rather than tropical.
+const siderealZodiac = z.enum(ZODIACS).default("sidereal:lahiri")
+    .describe("sidereal ayanamsa (default sidereal:lahiri); these are sidereal techniques");
 // ----------------------------------------------------- resource payloads
 // Loaded lazily on first read of the accuracy resource and memoized. Kept off
 // the module top level so importing this file into the bundled Streamable HTTP
@@ -177,6 +181,40 @@ function chartPayload(engine, iso, lat, lon, hs, zodiac = "tropical") {
     };
 }
 const text = (obj) => ({ content: [{ type: "text", text: JSON.stringify(obj) }] });
+// ---------------------------------------------------------------- chart widget (MCP Apps / Apps SDK)
+// natal_chart and current_sky can render the chart wheel in-host (ChatGPT and
+// other MCP-UI / Apps-SDK hosts). The widget loads a self-contained bundle
+// (apps/web/widget -> /embed/chart-widget.js) directly in the host's own
+// sandbox — no nested iframe — and mounts caelus-wheel from the tool's
+// structuredContent. Server-side half only; see docs/mcp-app-wiring.md.
+const EMBED_ORIGIN = process.env.CAELUS_EMBED_ORIGIN ?? "https://www.ephemengine.com";
+const CHART_WIDGET_URI = "ui://widget/chart.html";
+// The MCP Apps UI MIME type (current). Hosts only enable the UI bridge for it;
+// ChatGPT additionally honours the legacy openai/* _meta aliases set below.
+const CHART_WIDGET_MIME = "text/html;profile=mcp-app";
+// Bind the two chart tools to the widget. Both the standard (_meta.ui.resourceUri)
+// and the ChatGPT compatibility alias (openai/outputTemplate) point at the same
+// resource, so the binding survives across hosts.
+const CHART_TOOL_META = {
+    ui: { resourceUri: CHART_WIDGET_URI },
+    "openai/outputTemplate": CHART_WIDGET_URI,
+};
+// The widget shell: a root element plus the bundle loaded directly from the
+// embed origin (a script, not an iframe — so the CSP needs only resourceDomains,
+// never the heavily-scrutinised frameDomains). The bundle reads the chart from
+// the MCP Apps tool-result message / window.openai.toolOutput. `version` is a
+// cache-buster so a release always loads fresh JS.
+const chartWidgetHtml = (version) => `<!doctype html><meta charset="utf-8">
+<style>html,body{margin:0;height:100%;background:#0e0e14}#caelus-chart-root{position:fixed;inset:0;display:grid;place-items:center;overflow:hidden}</style>
+<div id="caelus-chart-root"></div>
+<script src="${EMBED_ORIGIN}/embed/chart-widget.js?v=${encodeURIComponent(version)}"></script>`;
+// Tool result for the two chart tools: the existing text payload (unchanged for
+// non-UI clients) plus structuredContent, which UI hosts hand to the widget as
+// its tool output. The two carry the same object.
+const chartResult = (payload) => ({
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    structuredContent: payload,
+});
 // ---------------------------------------------------------------- output schemas
 // Exported so the integration test validates responses against the same shape
 // the server promises. Kept permissive on optional keys (rx, fallback fields).
@@ -360,10 +398,74 @@ const directionOut = z.object({
     years: z.number(),
     date: z.string(),
 });
+const mundaneDirectionOut = z.object({
+    promissor: z.string(),
+    significator: z.string(),
+    arc: z.number(),
+    years: z.number(),
+    date: z.string(),
+});
 export const directionsOut = z.object({
     natal_utc: z.string(),
     key: z.enum(["ptolemy", "naibod"]),
     directions: z.array(directionOut),
+    mundane: z.array(mundaneDirectionOut).optional(),
+});
+export const nakshatrasOut = z.object({
+    natal_utc: z.string(),
+    zodiac: z.enum(ZODIACS),
+    points: z.record(z.string(), z.object({
+        nakshatra: z.string(),
+        pada: z.number().int().min(1).max(4),
+        lord: z.string(),
+        deg: z.number(),
+    })),
+});
+const dashaSubOut = z.object({
+    lord: z.string().optional(),
+    yogini: z.string().optional(),
+    start: z.string(),
+    end: z.string(),
+});
+export const dashaOut = z.object({
+    natal_utc: z.string(),
+    system: z.enum(["vimshottari", "yogini", "ashtottari"]),
+    moon_nakshatra: z.string(),
+    start_lord: z.string().optional(),
+    start_yogini: z.string().optional(),
+    balance_years: z.number(),
+    periods: z.array(z.object({
+        lord: z.string().optional(),
+        yogini: z.string().optional(),
+        start: z.string(),
+        end: z.string(),
+        sub: z.array(dashaSubOut).optional(),
+    })),
+    active: z.object({
+        target_utc: z.string(),
+        maha: z.string().nullable(),
+        antar: z.string().nullable(),
+        pratyantar: z.string().nullable().optional(),
+    }).optional(),
+});
+export const vargasOut = z.object({
+    natal_utc: z.string(),
+    zodiac: z.enum(ZODIACS),
+    charts: z.record(z.string(), z.record(z.string(), z.object({
+        sign: z.string(),
+        sign_index: z.number().int().min(0).max(11),
+        division: z.number().int(),
+    }))),
+});
+const lordPairOut = z.object({ lords: z.array(z.string()), via: z.string() });
+export const yogasOut = z.object({
+    natal_utc: z.string(),
+    zodiac: z.enum(ZODIACS),
+    yogas: z.array(z.object({ yoga: z.string(), planets: z.array(z.string()) })),
+    kemadruma: z.boolean(),
+    raja_yogas: z.array(lordPairOut),
+    dhana_yogas: z.array(lordPairOut),
+    yogakarakas: z.array(z.string()),
 });
 export const OUTPUT_SCHEMAS = {
     natal_chart: chartOut,
@@ -384,13 +486,19 @@ export const OUTPUT_SCHEMAS = {
     firdaria: firdariaOut,
     releasing: releasingOut,
     directions: directionsOut,
+    nakshatras: nakshatrasOut,
+    dasha: dashaOut,
+    vargas: vargasOut,
+    yogas: yogasOut,
 };
 export function buildServer(engine = defaultEngine(), opts = {}) {
-    const server = new McpServer({ name: "caelus", version: opts.version ?? VERSION });
+    const version = opts.version ?? VERSION;
+    const server = new McpServer({ name: "caelus", version });
     server.registerTool("natal_chart", {
         description: "A person's birth chart. Requires their exact birth date+time and birthplace (all three: date, lat, lon). Use this — not current_sky — whenever the question is about someone's natal/birth chart. Returns 13 bodies (sun–pluto, chiron, nodes) with sign, house, retrograde, speed; ASC/MC; cusps; major aspects with orbs. Vs Swiss Ephemeris (1900–2099): Sun–Saturn ≤1″, Uranus ≤1.9″, Neptune ≤4.6″, Moon ≤2.5″, Pluto ≤2.5″ (series valid 1885–2099), Chiron ≤1″, mean node ≤1″, true node ≤ 1′ vs SE's built-in ephemeris.",
         inputSchema: { ...birth, house_system: houseSys, zodiac: zodiacSchema },
-    }, async ({ date, lat, lon, house_system, zodiac }) => text(chartPayload(engine, date, lat, lon, house_system, zodiac)));
+        _meta: CHART_TOOL_META,
+    }, async ({ date, lat, lon, house_system, zodiac }) => chartResult(chartPayload(engine, date, lat, lon, house_system, zodiac)));
     server.registerTool("current_sky", {
         description: "The sky at a moment and place — not tied to any person. Use for \"what's the sky/transits right now\" or the chart of a non-birth event. Date defaults to now; lat/lon default to 0,0 (geocentric on the equator at the prime meridian), where houses and ASC/MC are nominal — pass a real location if houses matter. For a specific person's birth chart use natal_chart instead. Returns positions, houses, retrogrades, aspects.",
         inputSchema: {
@@ -400,7 +508,8 @@ export function buildServer(engine = defaultEngine(), opts = {}) {
             house_system: houseSys,
             zodiac: zodiacSchema,
         },
-    }, async ({ date, lat, lon, house_system, zodiac }) => text(chartPayload(engine, date ?? new Date().toISOString(), lat, lon, house_system, zodiac)));
+        _meta: CHART_TOOL_META,
+    }, async ({ date, lat, lon, house_system, zodiac }) => chartResult(chartPayload(engine, date ?? new Date().toISOString(), lat, lon, house_system, zodiac)));
     server.registerTool("transits", {
         description: "Transiting planets vs natal chart: aspects within orb (applying/separating), natal house per transiting body.",
         inputSchema: {
@@ -891,16 +1000,17 @@ export function buildServer(engine = defaultEngine(), opts = {}) {
         return text(payload);
     });
     server.registerTool("directions", {
-        description: "Primary (mundane) directions of the seven traditional planets to the four angles (MC, IC, Ascendant, Descendant). The diurnal rotation carries each body to an angle; the arc of rotation, converted by a time key (Naibod 0.9856473°/yr by default, or Ptolemy 1°/yr), gives the age of the direction. Returns the directions within max_years, sorted by age, each with its arc, age in years, and UTC date. Circumpolar bodies have no Ascendant/Descendant directions. Needs the birth time and place; equatorial, so zodiac is irrelevant.",
+        description: "Primary (mundane) directions of the seven traditional planets to the four angles (MC, IC, Ascendant, Descendant), and optionally between the planets themselves. The diurnal rotation carries a body to the angle (or a promissor to a significator); the arc of rotation, converted by a time key (Naibod 0.9856473°/yr by default, or Ptolemy 1°/yr), gives the age of the direction. Returns the directions within max_years, sorted by age, each with its arc, age in years, and UTC date. With include_mundane, also returns the planet-to-planet (promissor → significator) directions. Circumpolar bodies have no Ascendant/Descendant directions. Needs the birth time and place; equatorial, so zodiac is irrelevant.",
         inputSchema: {
             ...birth,
             key: z.enum(["naibod", "ptolemy"]).optional().describe("time key: naibod (0.9856473°/yr, default) or ptolemy (1°/yr)"),
             max_years: z.number().positive().optional().describe("only directions reached within this many years of life (default 90)"),
+            include_mundane: z.boolean().optional().describe("also return inter-planetary (promissor → significator) directions (default false)"),
         },
-    }, async ({ date, lat, lon, key = "naibod", max_years = 90 }) => {
+    }, async ({ date, lat, lon, key = "naibod", max_years = 90, include_mundane = false }) => {
         const natalJd = jdFromIso(date);
         const dirs = primaryDirections(engine, natalJd, lat, lon, undefined, key, max_years);
-        return text({
+        const payload = {
             natal_utc: date,
             key,
             directions: dirs.map((d) => ({
@@ -910,9 +1020,167 @@ export function buildServer(engine = defaultEngine(), opts = {}) {
                 years: r2(d.years),
                 date: isoFromJd(d.jd),
             })),
+        };
+        if (include_mundane) {
+            const mundane = mundaneDirections(engine, natalJd, lat, lon, undefined, key, max_years);
+            payload.mundane = mundane.map((d) => ({
+                promissor: d.promissor,
+                significator: d.significator,
+                arc: r2(d.arc),
+                years: r2(d.years),
+                date: isoFromJd(d.jd),
+            }));
+        }
+        return text(payload);
+    });
+    server.registerTool("nakshatras", {
+        description: "The nakshatra (one of the 27 lunar mansions of 13°20′) of each classical point on the sidereal zodiac: the seven traditional planets and the Ascendant (lagna). Per point: the nakshatra name, its pada (quarter, 1–4), the ruling planet (the Vimshottari lord), and degrees into the nakshatra. The Moon's nakshatra (janma nakshatra) anchors the Vimshottari dasha. Sidereal by definition; Lahiri ayanamsa by default. Needs the birth time and place for the Ascendant.",
+        inputSchema: { ...birth, zodiac: siderealZodiac },
+    }, async ({ date, lat, lon, zodiac }) => {
+        const natalJd = jdFromIso(date);
+        const chart = engine.chartAt(natalJd, lat, lon, { zodiac });
+        const desc = (lonDeg) => {
+            const n = nakshatra(lonDeg);
+            return { nakshatra: n.name, pada: n.pada, lord: n.lord, deg: r2(n.pos) };
+        };
+        const points = {};
+        for (const b of TRADITIONAL)
+            points[b] = desc(chart.bodies[b].lon);
+        points.asc = desc(chart.angles.asc);
+        return text({ natal_utc: date, zodiac, points });
+    });
+    server.registerTool("dasha", {
+        description: "Vedic dasha periods — planetary time-lord cycles started from the Moon's birth nakshatra. system selects Vimshottari (120-year, the standard), Yogini (36-year, eight yoginis), or Ashtottari (108-year). Returns the period timeline (mahadasha → antardasha) with UTC start/end, the balance of the first period at birth, and — when target_date is given — the lords active then (Vimshottari also gives the pratyantardasha). Sidereal; Lahiri by default. Needs the birth time and place.",
+        inputSchema: {
+            ...birth,
+            system: z.enum(["vimshottari", "yogini", "ashtottari"]).default("vimshottari")
+                .describe("dasha system: vimshottari (120y), yogini (36y), or ashtottari (108y)"),
+            target_date: z.string().optional().describe("UTC ISO date to read the active lords for; omit for the timeline only"),
+            levels: z.number().int().min(1).max(2).optional().describe("deepest timeline level: 1 (maha) or 2 (maha+antar, default)"),
+            zodiac: siderealZodiac,
+        },
+    }, async ({ date, lat, lon, system, target_date, levels = 2, zodiac }) => {
+        const natalJd = jdFromIso(date);
+        const moonLon = engine.longitude("moon", natalJd, { zodiac });
+        const moonNak = nakshatra(moonLon).name;
+        const targetJd = target_date !== undefined ? jdFromIso(target_date) : undefined;
+        const isoSub = (s) => ({ lord: s.lord, start: isoFromJd(s.start), end: isoFromJd(s.end) });
+        switch (system) {
+            case "vimshottari": {
+                const tl = vimshottariDashas(moonLon, natalJd, levels);
+                const periods = tl.dashas.map((d) => ({
+                    lord: d.lord, start: isoFromJd(d.start), end: isoFromJd(d.end),
+                    ...(levels >= 2 ? { sub: d.sub.map(isoSub) } : {}),
+                }));
+                const payload = {
+                    natal_utc: date, system, moon_nakshatra: moonNak,
+                    start_lord: tl.start_lord, balance_years: r2(tl.balance_years), periods,
+                };
+                if (targetJd !== undefined) {
+                    const a = vimshottariAt(engine, natalJd, targetJd, zodiac);
+                    payload.active = { target_utc: target_date, maha: a.maha ?? null, antar: a.antar ?? null, pratyantar: a.pratyantar ?? null };
+                }
+                return text(payload);
+            }
+            case "yogini": {
+                const tl = yoginiDashas(moonLon, natalJd, levels);
+                const periods = tl.dashas.map((d) => ({
+                    yogini: d.yogini, lord: d.lord, start: isoFromJd(d.start), end: isoFromJd(d.end),
+                    ...(levels >= 2 ? { sub: d.sub.map((s) => ({ yogini: s.yogini, lord: s.lord, start: isoFromJd(s.start), end: isoFromJd(s.end) })) } : {}),
+                }));
+                const payload = {
+                    natal_utc: date, system, moon_nakshatra: moonNak,
+                    start_yogini: tl.start_yogini, balance_years: r2(tl.balance_years), periods,
+                };
+                if (targetJd !== undefined) {
+                    const a = yoginiAt(engine, natalJd, targetJd, zodiac);
+                    payload.active = { target_utc: target_date, maha: a.maha ?? null, antar: a.antar ?? null };
+                }
+                return text(payload);
+            }
+            case "ashtottari": {
+                const tl = ashtottariDashas(moonLon, natalJd, levels);
+                const periods = tl.dashas.map((d) => ({
+                    lord: d.lord, start: isoFromJd(d.start), end: isoFromJd(d.end),
+                    ...(levels >= 2 ? { sub: d.sub.map(isoSub) } : {}),
+                }));
+                const payload = {
+                    natal_utc: date, system, moon_nakshatra: moonNak,
+                    start_lord: tl.start_lord, balance_years: r2(tl.balance_years), periods,
+                };
+                if (targetJd !== undefined) {
+                    const a = ashtottariAt(engine, natalJd, targetJd, zodiac);
+                    payload.active = { target_utc: target_date, maha: a.maha ?? null, antar: a.antar ?? null };
+                }
+                return text(payload);
+            }
+            default: {
+                const _exhaustive = system;
+                throw new Error(`unknown dasha system: ${String(_exhaustive)}`);
+            }
+        }
+    });
+    server.registerTool("vargas", {
+        description: "Parashari divisional charts (vargas): the sign of each of the seven planets and the Ascendant in the requested D-charts — D1 rasi, D2 hora, D3 drekkana, D9 navamsa, D10 dasamsa, D12 dwadasamsa, D30 trimsamsa. Per point in each chart: the divisional sign and the division number within the rasi. The navamsa (D9) is the most consulted after the rasi. Sidereal; Lahiri by default. Needs the birth time and place for the Ascendant.",
+        inputSchema: {
+            ...birth,
+            divisions: z.array(z.number().int().refine((n) => VARGA_DIVISIONS.includes(n), "unsupported division"))
+                .optional().describe(`subset of ${VARGA_DIVISIONS.join("/")} (default all)`),
+            zodiac: siderealZodiac,
+        },
+    }, async ({ date, lat, lon, divisions, zodiac }) => {
+        const natalJd = jdFromIso(date);
+        const chart = engine.chartAt(natalJd, lat, lon, { zodiac });
+        const ns = divisions && divisions.length ? divisions : VARGA_DIVISIONS;
+        const lons = { asc: chart.angles.asc };
+        for (const b of TRADITIONAL)
+            lons[b] = chart.bodies[b].lon;
+        const charts = {};
+        for (const n of ns) {
+            const c = {};
+            for (const [name, lonDeg] of Object.entries(lons)) {
+                const v = varga(lonDeg, n);
+                c[name] = { sign: v.sign, sign_index: v.sign_index, division: v.division };
+            }
+            charts[`D${n}`] = c;
+        }
+        return text({ natal_utc: date, zodiac, charts });
+    });
+    server.registerTool("yogas", {
+        description: "Vedic yogas (planetary combinations) on the sidereal rasi chart: the five Pancha Mahapurusha yogas (Ruchaka, Bhadra, Hamsa, Malavya, Shasha), Gajakesari, Budha-Aditya, and Chandra-Mangala; whether Kemadruma (the isolated-Moon yoga) is present; the raja yogas (a kendra lord associating with a trikona lord) and dhana (wealth) yogas, each as the lord pair and how they associate (conjunction, aspect, or exchange); and the chart's yogakarakas (a planet ruling both a kendra and a trikona). Sidereal; Lahiri by default. Needs the birth time and place.",
+        inputSchema: { ...birth, zodiac: siderealZodiac },
+    }, async ({ date, lat, lon, zodiac }) => {
+        const natalJd = jdFromIso(date);
+        const placement = yogasAt(engine, natalJd, lat, lon, zodiac);
+        const kema = kemadrumaAt(engine, natalJd, lat, lon, false, false, zodiac);
+        const { raja, yogakarakas } = rajaYogasAt(engine, natalJd, lat, lon, zodiac);
+        const dhana = dhanaYogasAt(engine, natalJd, lat, lon, zodiac);
+        return text({
+            natal_utc: date, zodiac,
+            yogas: placement,
+            kemadruma: kema.present,
+            raja_yogas: raja,
+            dhana_yogas: dhana,
+            yogakarakas,
         });
     });
     // --------------------------------------------------------- resources
+    // Chart wheel widget (MCP Apps / Apps SDK). The CSP allowlists the embed
+    // origin only for loading the widget script (resourceDomains) — no
+    // frameDomains, since the bundle renders directly in the host sandbox rather
+    // than nesting an iframe. The legacy openai/widgetCSP mirror keeps older
+    // ChatGPT happy.
+    server.registerResource("chart-widget", CHART_WIDGET_URI, {
+        title: "Chart wheel",
+        description: "Renders the natal_chart / current_sky payload as a caelus-wheel chart.",
+        mimeType: CHART_WIDGET_MIME,
+        _meta: {
+            ui: { csp: { connectDomains: [], resourceDomains: [EMBED_ORIGIN] } },
+            "openai/widgetCSP": { connect_domains: [], resource_domains: [EMBED_ORIGIN] },
+        },
+    }, async (uri) => ({
+        contents: [{ uri: uri.href, mimeType: CHART_WIDGET_MIME, text: chartWidgetHtml(version) }],
+    }));
     server.registerResource("accuracy", "caelus://accuracy", {
         title: "Validation table",
         description: "Per-body accuracy: vs Swiss Ephemeris (swiss) and JPL Horizons apparent positions (jpl).",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caelus-mcp",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "mcpName": "io.github.heavyblotto/caelus-mcp",
   "description": "MCP server for caelus chart computation.",
   "type": "module",
@@ -15,12 +15,16 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "zod": "^3.24.0",
-    "caelus": "^0.13.0"
+    "caelus": "^0.14.0"
   },
   "devDependencies": {
     "ajv": "^8.17.1"
   },
   "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "files": [
     "dist/src"
   ],