ether-to-astro 1.2.0 → 1.3.0

package/dist/astro-service.js

@@ -1,69 +1,26 @@
 import { writeFile } from 'node:fs/promises';
-import { Temporal } from '@js-temporal/polyfill';
+import { ChartOutputService } from './astro-service/chart-output-service.js';
+import { ElectionalService } from './astro-service/electional-service.js';
+import { NatalService } from './astro-service/natal-service.js';
+import { RisingSignService } from './astro-service/rising-sign-service.js';
+import { resolveReportingTimezone } from './astro-service/shared.js';
+import { SkyService } from './astro-service/sky-service.js';
+import { TransitService } from './astro-service/transit-service.js';
 import { ChartRenderer } from './charts.js';
-import { getDefaultTheme } from './constants.js';
 import { EclipseCalculator } from './eclipses.js';
 import { EphemerisCalculator } from './ephemeris.js';
-import { formatDateOnly, formatInTimezone } from './formatter.js';
+import { formatInTimezone } from './formatter.js';
 import { HouseCalculator } from './houses.js';
 import { RiseSetCalculator } from './riseset.js';
-import { addLocalDays, formatLocalTimestampWithOffset, localToUTC, utcToLocal, } from './time-utils.js';
-import { deduplicateTransits, TransitCalculator } from './transits.js';
-import { ASPECTS, ASTEROIDS, NODES, OUTER_PLANETS, PERSONAL_PLANETS, PLANET_NAMES, PLANETS, ZODIAC_SIGNS, } from './types.js';
-export function parseDateOnlyInput(dateStr) {
-    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(dateStr);
-    if (!match) {
-        throw new Error(`Invalid date format: expected YYYY-MM-DD, got "${dateStr}"`);
-    }
-    const year = Number(match[1]);
-    const month = Number(match[2]);
-    const day = Number(match[3]);
-    if (month < 1 || month > 12) {
-        throw new Error(`Invalid month: ${month} (must be 1-12)`);
-    }
-    if (day < 1 || day > 31) {
-        throw new Error(`Invalid day: ${day} (must be 1-31)`);
-    }
-    try {
-        Temporal.PlainDate.from({ year, month, day });
-    }
-    catch {
-        throw new Error(`Invalid calendar date: ${dateStr}`);
-    }
-    return { year, month, day, hour: 12, minute: 0 };
-}
-function parseTimeOnlyInput(timeStr) {
-    const match = /^(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(timeStr);
-    if (!match) {
-        throw new Error(`Invalid time format: expected HH:mm[:ss], got "${timeStr}"`);
-    }
-    const hour = Number(match[1]);
-    const minute = Number(match[2]);
-    const second = match[3] === undefined ? 0 : Number(match[3]);
-    if (hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 59) {
-        throw new Error(`Invalid clock time: ${timeStr}`);
-    }
-    try {
-        Temporal.PlainTime.from({ hour, minute, second });
-    }
-    catch {
-        throw new Error(`Invalid clock time: ${timeStr}`);
-    }
-    return { hour, minute, second };
-}
-const ELECTIONAL_CONTEXT_PLANET_IDS = [
-    PLANETS.SUN,
-    PLANETS.MOON,
-    PLANETS.MERCURY,
-    PLANETS.VENUS,
-    PLANETS.MARS,
-    PLANETS.JUPITER,
-    PLANETS.SATURN,
-    PLANETS.URANUS,
-    PLANETS.NEPTUNE,
-    PLANETS.PLUTO,
-];
-const ELECTIONAL_CONTEXT_HOUSE_SYSTEMS = ['P', 'K', 'W', 'R'];
+import { TransitCalculator } from './transits.js';
+export { parseDateOnlyInput } from './astro-service/date-input.js';
+/**
+ * Shared service facade used by both the MCP server and the CLI.
+ *
+ * @remarks
+ * Public methods remain the stable orchestration boundary while domain-specific
+ * internals can be extracted behind the class without changing callers.
+ */
 export class AstroService {
     ephem;
     transitCalc;
@@ -72,6 +29,12 @@ export class AstroService {
     eclipseCalc;
     chartRenderer;
     mcpStartupDefaults;
+    transitService;
+    electionalService;
+    risingSignService;
+    natalService;
+    skyService;
+    chartOutputService;
     now;
     writeFileFn;
     constructor(deps = {}) {
@@ -84,1017 +47,174 @@ export class AstroService {
         this.mcpStartupDefaults = Object.freeze({ ...(deps.mcpStartupDefaults ?? {}) });
         this.now = deps.now ?? (() => new Date());
         this.writeFileFn = deps.writeFile ?? writeFile;
+        this.transitService = new TransitService({
+            ephem: this.ephem,
+            transitCalc: this.transitCalc,
+            houseCalc: this.houseCalc,
+            mcpStartupDefaults: this.mcpStartupDefaults,
+            now: this.now,
+            formatTimestamp: this.formatTimestamp.bind(this),
+        });
+        this.electionalService = new ElectionalService({
+            ephem: this.ephem,
+            houseCalc: this.houseCalc,
+        });
+        this.risingSignService = new RisingSignService({
+            ephem: this.ephem,
+            houseCalc: this.houseCalc,
+        });
+        this.natalService = new NatalService({
+            ephem: this.ephem,
+            houseCalc: this.houseCalc,
+            mcpStartupDefaults: this.mcpStartupDefaults,
+            isInitialized: this.isInitialized.bind(this),
+        });
+        this.skyService = new SkyService({
+            ephem: this.ephem,
+            riseSetCalc: this.riseSetCalc,
+            eclipseCalc: this.eclipseCalc,
+            mcpStartupDefaults: this.mcpStartupDefaults,
+            now: this.now,
+            formatTimestamp: this.formatTimestamp.bind(this),
+        });
+        this.chartOutputService = new ChartOutputService({
+            chartRenderer: this.chartRenderer,
+            now: this.now,
+            writeFile: this.writeFileFn,
+        });
     }
+    /**
+     * Format user-facing timestamps using the current startup default weekday policy.
+     */
     formatTimestamp(date, timezone) {
         return formatInTimezone(date, timezone, {
             weekday: this.mcpStartupDefaults.weekdayLabels ?? false,
         });
     }
-    normalizeLongitude(longitude) {
-        return ((longitude % 360) + 360) % 360;
-    }
-    getSignAndDegree(longitude) {
-        const normalized = this.normalizeLongitude(longitude);
-        const baseSignIndex = Math.floor(normalized / 30);
-        const roundedDegree = Number.parseFloat((normalized % 30).toFixed(2));
-        const shouldCarryToNextSign = roundedDegree >= 30;
-        const signIndex = shouldCarryToNextSign
-            ? (baseSignIndex + 1) % ZODIAC_SIGNS.length
-            : baseSignIndex;
-        return {
-            sign: ZODIAC_SIGNS[signIndex],
-            degree: shouldCarryToNextSign ? 0 : roundedDegree,
-        };
-    }
-    getHouseNumber(longitude, houses) {
-        const normalized = this.normalizeLongitude(longitude);
-        for (let house = 1; house <= 12; house++) {
-            const start = this.normalizeLongitude(houses.cusps[house]);
-            const nextHouse = house === 12 ? 1 : house + 1;
-            const end = this.normalizeLongitude(houses.cusps[nextHouse]);
-            const span = (end - start + 360) % 360;
-            const offset = (normalized - start + 360) % 360;
-            if (span === 0 || offset === 0 || offset < span) {
-                return house;
-            }
-        }
-        return 12;
-    }
-    resolveHouseSystem(natalChart, explicitSystem) {
-        return (explicitSystem ||
-            natalChart.requestedHouseSystem ||
-            this.mcpStartupDefaults.preferredHouseStyle ||
-            natalChart.houseSystem ||
-            'P');
-    }
-    resolveTimezones(explicitReportingTimezone, natalTimezone) {
-        return {
-            calculationTimezone: natalTimezone ?? 'UTC',
-            reportingTimezone: this.resolveReportingTimezone(explicitReportingTimezone, natalTimezone),
-        };
-    }
+    /**
+     * Resolve the timezone used for user-facing timestamps and labels.
+     *
+     * @remarks
+     * Explicit per-call timezone wins, then startup defaults, then the natal chart
+     * timezone, and finally UTC.
+     */
     resolveReportingTimezone(explicitTimezone, natalTimezone) {
-        return explicitTimezone ?? this.mcpStartupDefaults.preferredTimezone ?? natalTimezone ?? 'UTC';
+        return resolveReportingTimezone(this.mcpStartupDefaults, explicitTimezone, natalTimezone);
     }
+    /**
+     * Initialize the underlying ephemeris engine.
+     */
     async init() {
         await this.ephem.init();
     }
+    /**
+     * Report whether the ephemeris engine has been initialized.
+     */
     isInitialized() {
         return !!this.ephem.eph;
     }
+    /**
+     * Build and cache the shared natal chart payload used by later workflows.
+     *
+     * @remarks
+     * This preserves the existing natal contract, including polar-latitude house
+     * fallback behavior and the current user-facing summary text.
+     */
     setNatalChart(input) {
-        const requestedHouseSystem = input.house_system ?? null;
-        const chart = {
-            name: input.name,
-            birthDate: {
-                year: input.year,
-                month: input.month,
-                day: input.day,
-                hour: input.hour,
-                minute: input.minute,
-            },
-            location: {
-                latitude: input.latitude,
-                longitude: input.longitude,
-                timezone: input.timezone,
-            },
-        };
-        const birthTimeDisambiguation = input.birth_time_disambiguation ?? 'reject';
-        const utcDate = localToUTC(chart.birthDate, chart.location.timezone, birthTimeDisambiguation);
-        const utcComponents = utcToLocal(utcDate, 'UTC');
-        const jd = this.ephem.dateToJulianDay(utcDate);
-        const planetIds = Object.values(PLANETS);
-        const positions = this.ephem.getAllPlanets(jd, planetIds);
-        const isPolar = Math.abs(chart.location.latitude) > 66;
-        let houseSystem = requestedHouseSystem || 'P';
-        if (isPolar && houseSystem === 'P') {
-            houseSystem = 'W';
-        }
-        const houses = this.houseCalc.calculateHouses(jd, chart.location.latitude, chart.location.longitude, houseSystem);
-        const storedChart = {
-            ...chart,
-            planets: positions,
-            julianDay: jd,
-            houseSystem: houses.system,
-            requestedHouseSystem: requestedHouseSystem ?? undefined,
-            utcDateTime: utcComponents,
-        };
-        const sun = positions.find((p) => p.planet === 'Sun');
-        const moon = positions.find((p) => p.planet === 'Moon');
-        if (!sun || !moon) {
-            throw new Error('Ephemeris failed to compute Sun/Moon positions for natal chart.');
-        }
-        const formatDegree = (lon) => {
-            const sign = ZODIAC_SIGNS[Math.floor(lon / 30)];
-            const degree = lon % 30;
-            return `${degree.toFixed(0)}° ${sign}`;
-        };
-        const localTimeStr = `${chart.birthDate.month}/${chart.birthDate.day}/${chart.birthDate.year} ${chart.birthDate.hour}:${String(chart.birthDate.minute).padStart(2, '0')}`;
-        const utcTimeStr = `${utcComponents.month}/${utcComponents.day}/${utcComponents.year} ${utcComponents.hour}:${String(utcComponents.minute).padStart(2, '0')} UTC`;
-        const systemNames = {
-            P: 'Placidus',
-            W: 'Whole Sign',
-            K: 'Koch',
-            E: 'Equal',
-        };
-        const latDir = chart.location.latitude >= 0 ? 'N' : 'S';
-        const lonDir = chart.location.longitude >= 0 ? 'E' : 'W';
-        const latAbs = Math.abs(chart.location.latitude);
-        const lonAbs = Math.abs(chart.location.longitude);
-        const feedback = [
-            `Natal chart saved for ${chart.name}`,
-            '',
-            'Birth Details:',
-            `- Local Time: ${localTimeStr} (${chart.location.timezone})`,
-            `- UTC Time: ${utcTimeStr}`,
-            `- Location: ${latAbs.toFixed(2)}°${latDir}, ${lonAbs.toFixed(2)}°${lonDir}`,
-            '',
-            'Chart Angles:',
-            `- Sun: ${formatDegree(sun.longitude)}`,
-            `- Moon: ${formatDegree(moon.longitude)}`,
-            `- Ascendant: ${formatDegree(houses.ascendant)}`,
-            `- MC: ${formatDegree(houses.mc)}`,
-            '',
-            `House System: ${systemNames[houses.system] || houses.system}`,
-        ];
-        if (isPolar && houses.system !== houseSystem) {
-            feedback.push('', `Note: Polar latitude detected (${chart.location.latitude.toFixed(1)}°). Requested ${systemNames[houseSystem]}, using ${systemNames[houses.system]} instead.`);
-        }
-        else if (isPolar) {
-            feedback.push('', `Note: Polar latitude detected (${chart.location.latitude.toFixed(1)}°). Using ${systemNames[houses.system]} house system.`);
-        }
-        const structuredData = {
-            name: chart.name,
-            birthTime: {
-                local: localTimeStr,
-                utc: utcTimeStr,
-                timezone: chart.location.timezone,
-            },
-            location: {
-                latitude: chart.location.latitude,
-                longitude: chart.location.longitude,
-            },
-            julianDay: jd,
-            requestedHouseSystem,
-            resolvedHouseSystem: houses.system,
-            angles: {
-                sun: formatDegree(sun.longitude),
-                moon: formatDegree(moon.longitude),
-                ascendant: formatDegree(houses.ascendant),
-                mc: formatDegree(houses.mc),
-            },
-            isPolar,
-        };
-        return {
-            chart: storedChart,
-            data: structuredData,
-            text: feedback.join('\n'),
-        };
-    }
+        return this.natalService.setNatalChart(input);
+    }
+    /**
+     * Calculate natal transits while preserving the public service contract.
+     *
+     * @remarks
+     * Transit day interpretation uses the natal chart timezone for calculation and
+     * may use a different reporting timezone for labels when startup defaults are set.
+     */
     getTransits(natalChart, input = {}) {
-        const dateStr = input.date;
-        const categories = input.categories ?? ['all'];
-        const includeMundane = input.include_mundane ?? false;
-        const daysAhead = input.days_ahead ?? 0;
-        const requestedMode = input.mode;
-        const maxOrb = input.max_orb ?? 8;
-        const exactOnly = input.exact_only ?? false;
-        const applyingOnly = input.applying_only ?? false;
-        if (!Number.isFinite(daysAhead) || daysAhead < 0) {
-            throw new Error('days_ahead must be a finite number >= 0');
-        }
-        if (!Number.isFinite(maxOrb) || maxOrb < 0) {
-            throw new Error('max_orb must be a finite number >= 0');
-        }
-        if (requestedMode !== undefined &&
-            requestedMode !== 'snapshot' &&
-            requestedMode !== 'best_hit' &&
-            requestedMode !== 'forecast') {
-            throw new Error('mode must be one of: snapshot, best_hit, forecast');
-        }
-        if (!natalChart.julianDay) {
-            throw new Error('Natal chart is missing julianDay. Re-run set_natal_chart to fix.');
-        }
-        const mode = requestedMode ?? (daysAhead === 0 ? 'snapshot' : 'best_hit');
-        const modeSource = requestedMode === undefined ? 'legacy_default' : 'explicit';
-        let transitingPlanetIds = [];
-        if (categories.includes('all')) {
-            transitingPlanetIds = Object.values(PLANETS);
-        }
-        else {
-            if (categories.includes('moon'))
-                transitingPlanetIds.push(PLANETS.MOON);
-            if (categories.includes('personal')) {
-                transitingPlanetIds.push(...PERSONAL_PLANETS.filter((p) => !transitingPlanetIds.includes(p)));
-            }
-            if (categories.includes('outer')) {
-                transitingPlanetIds.push(...OUTER_PLANETS.filter((p) => !transitingPlanetIds.includes(p)));
-            }
-        }
-        const { calculationTimezone, reportingTimezone } = this.resolveTimezones(undefined, natalChart.location.timezone);
-        let targetDate;
-        if (dateStr) {
-            const parsed = parseDateOnlyInput(dateStr);
-            targetDate = localToUTC(parsed, calculationTimezone);
-        }
-        else {
-            const now = this.now();
-            const localNow = utcToLocal(now, calculationTimezone);
-            const localNoon = { ...localNow, hour: 12, minute: 0, second: 0 };
-            targetDate = localToUTC(localNoon, calculationTimezone);
-        }
-        const allTransits = [];
-        const transitsByDay = new Map();
-        const transitContext = new WeakMap();
-        const startLocal = utcToLocal(targetDate, calculationTimezone);
-        const effectiveDaysAhead = mode === 'snapshot' ? 0 : daysAhead;
-        for (let day = 0; day <= effectiveDaysAhead; day++) {
-            const dayUTC = addLocalDays(startLocal, calculationTimezone, day);
-            const jd = this.ephem.dateToJulianDay(dayUTC);
-            const transitingPlanets = this.ephem.getAllPlanets(jd, transitingPlanetIds);
-            const transits = this.transitCalc.findTransits(transitingPlanets, natalChart.planets || [], jd);
-            for (const transit of transits) {
-                transitContext.set(transit, { julianDay: jd });
-            }
-            allTransits.push(...transits);
-            const dayLocal = utcToLocal(dayUTC, reportingTimezone);
-            const dayLabel = `${dayLocal.year}-${String(dayLocal.month).padStart(2, '0')}-${String(dayLocal.day).padStart(2, '0')}`;
-            transitsByDay.set(dayLabel, transits);
-        }
-        const filterTransits = (transits) => {
-            let filtered = transits.filter((t) => t.orb <= maxOrb);
-            if (exactOnly)
-                filtered = filtered.filter((t) => t.exactTime !== undefined);
-            if (applyingOnly)
-                filtered = filtered.filter((t) => t.isApplying);
-            filtered.sort((a, b) => a.orb - b.orb);
-            return filtered;
-        };
-        const chartHouseSystem = this.resolveHouseSystem(natalChart);
-        const natalHouses = this.houseCalc.calculateHouses(natalChart.julianDay, natalChart.location.latitude, natalChart.location.longitude, chartHouseSystem);
-        const transitHouseCache = new Map();
-        const planetIdsByName = new Map(Object.entries(PLANET_NAMES).map(([id, name]) => [name, Number(id)]));
-        const getTransitHouses = (julianDay) => {
-            const cached = transitHouseCache.get(julianDay);
-            if (cached) {
-                return cached;
-            }
-            const houses = this.houseCalc.calculateHouses(julianDay, natalChart.location.latitude, natalChart.location.longitude, chartHouseSystem);
-            transitHouseCache.set(julianDay, houses);
-            return houses;
-        };
-        const serializeTransit = (t) => {
-            const transitPlacement = this.getSignAndDegree(t.transitLongitude);
-            const natalPlacement = this.getSignAndDegree(t.natalLongitude);
-            const context = transitContext.get(t);
-            const transitHouseJulianDay = t.exactTime
-                ? this.ephem.dateToJulianDay(t.exactTime)
-                : (context?.julianDay ?? this.ephem.dateToJulianDay(targetDate));
-            const transitHouses = getTransitHouses(transitHouseJulianDay);
-            const exactTransitLongitude = t.exactTime && planetIdsByName.has(t.transitingPlanet)
-                ? this.ephem.getPlanetPosition(planetIdsByName.get(t.transitingPlanet), transitHouseJulianDay).longitude
-                : t.transitLongitude;
-            return {
-                transitingPlanet: t.transitingPlanet,
-                aspect: t.aspect,
-                natalPlanet: t.natalPlanet,
-                orb: Number.parseFloat(t.orb.toFixed(2)),
-                isApplying: t.isApplying,
-                exactTimeStatus: t.exactTimeStatus,
-                exactTime: t.exactTime?.toISOString(),
-                transitLongitude: t.transitLongitude,
-                natalLongitude: t.natalLongitude,
-                transitSign: transitPlacement.sign,
-                transitDegree: transitPlacement.degree,
-                transitHouse: this.getHouseNumber(exactTransitLongitude, transitHouses),
-                natalSign: natalPlacement.sign,
-                natalDegree: natalPlacement.degree,
-                natalHouse: this.getHouseNumber(t.natalLongitude, natalHouses),
-            };
-        };
-        const filteredTransits = mode === 'forecast'
-            ? filterTransits(deduplicateTransits(allTransits))
-            : filterTransits(deduplicateTransits(allTransits));
-        const localDate = utcToLocal(targetDate, reportingTimezone);
-        const dateLabel = `${localDate.year}-${String(localDate.month).padStart(2, '0')}-${String(localDate.day).padStart(2, '0')}`;
-        const endLocal = utcToLocal(addLocalDays(startLocal, calculationTimezone, effectiveDaysAhead), reportingTimezone);
-        const windowEndLabel = `${endLocal.year}-${String(endLocal.month).padStart(2, '0')}-${String(endLocal.day).padStart(2, '0')}`;
-        const structuredData = {
-            date: dateLabel,
-            timezone: reportingTimezone,
-            calculation_timezone: calculationTimezone,
-            reporting_timezone: reportingTimezone,
-            transits: filteredTransits.map(serializeTransit),
-        };
-        const metadata = {
-            mode,
-            mode_source: modeSource,
-            days_ahead: effectiveDaysAhead,
-            window_start: dateLabel,
-            window_end: windowEndLabel,
-        };
-        let responseData = structuredData;
-        let mundaneText = '';
-        if (mode === 'forecast') {
-            const forecastDays = Array.from(transitsByDay.entries())
-                .sort(([a], [b]) => a.localeCompare(b))
-                .map(([dayDate, dayTransits]) => ({
-                date: dayDate,
-                transits: filterTransits(deduplicateTransits(dayTransits)).map(serializeTransit),
-            }));
-            responseData = {
-                ...metadata,
-                timezone: reportingTimezone,
-                calculation_timezone: calculationTimezone,
-                reporting_timezone: reportingTimezone,
-                forecast: forecastDays,
-            };
-        }
-        else {
-            responseData = {
-                ...structuredData,
-                ...metadata,
-            };
-        }
-        if (includeMundane) {
-            const mundaneDays = [];
-            for (let day = 0; day <= daysAhead; day++) {
-                const dayUTC = addLocalDays(startLocal, calculationTimezone, day);
-                mundaneDays.push(this.getMundaneDay(dayUTC, reportingTimezone, transitingPlanetIds));
-            }
-            const [anchorMundane] = mundaneDays;
-            const mundaneData = {
-                date: anchorMundane.date,
-                timezone: anchorMundane.timezone,
-                positions: anchorMundane.positions,
-                aspects: anchorMundane.aspects,
-                days: mundaneDays,
-            };
-            responseData = { transits: responseData, mundane: mundaneData };
-            mundaneText = `\n\nCurrent Planetary Positions:\n\n${anchorMundane.positions
-                .map((p) => `${p.planet}: ${p.degree.toFixed(1)}° ${p.sign} (${p.isRetrograde ? 'Rx' : 'Direct'})`)
-                .join('\n')}`;
-            if (mode === 'forecast') {
-                mundaneText +=
-                    '\n\nNote: mundane positions remain anchored to the forecast start date in this mode.';
-            }
-        }
-        const formatHumanTransit = (t) => {
-            const exactStr = t.exactTime
-                ? ` - Exact: ${this.formatTimestamp(t.exactTime, reportingTimezone)}`
-                : '';
-            const applyStr = t.isApplying ? '(applying)' : '(separating)';
-            return `${t.transitingPlanet} ${t.aspect} ${t.natalPlanet}: ${t.orb.toFixed(2)}° orb ${applyStr}${exactStr}`;
-        };
-        const rangeStr = effectiveDaysAhead > 0 ? ` (next ${effectiveDaysAhead + 1} days)` : '';
-        let transitHeader;
-        if (mode === 'forecast') {
-            const forecastLines = Array.from(transitsByDay.entries())
-                .sort(([a], [b]) => a.localeCompare(b))
-                .map(([dayDate, dayTransits]) => {
-                const dedupedDay = filterTransits(deduplicateTransits(dayTransits));
-                const lines = dedupedDay.length === 0
-                    ? 'No transits found matching the specified criteria.'
-                    : dedupedDay.map(formatHumanTransit).join('\n');
-                return `${dayDate}:\n${lines}`;
-            })
-                .join('\n\n');
-            transitHeader = `Forecast transits${rangeStr}:\n\n${forecastLines}`;
-        }
-        else {
-            const humanLines = filteredTransits.map(formatHumanTransit).join('\n');
-            const modeLabel = mode === 'snapshot' ? 'Transit snapshot' : 'Best-hit transits';
-            transitHeader =
-                filteredTransits.length > 0
-                    ? `${modeLabel}${rangeStr}:\n\n${humanLines}`
-                    : 'No transits found matching the specified criteria.';
-        }
-        return {
-            data: responseData,
-            text: transitHeader + mundaneText,
-        };
-    }
-    getMundaneWeather(aspects) {
-        const supportiveAspects = new Set(['conjunction', 'trine', 'sextile']);
-        const challengingAspects = new Set(['square', 'opposition']);
-        return {
-            supportive: aspects.filter((a) => supportiveAspects.has(a.aspect)).map((a) => a.id),
-            challenging: aspects.filter((a) => challengingAspects.has(a.aspect)).map((a) => a.id),
-        };
-    }
-    getMundaneAspects(date, positions) {
-        const aspects = [];
-        for (let i = 0; i < positions.length; i++) {
-            for (let j = i + 1; j < positions.length; j++) {
-                const planetA = positions[i];
-                const planetB = positions[j];
-                const angle = this.ephem.calculateAspectAngle(planetA.longitude, planetB.longitude);
-                for (const aspect of ASPECTS) {
-                    const orb = Math.abs(angle - aspect.angle);
-                    if (orb > aspect.orb) {
-                        continue;
-                    }
-                    const futureLongitudeA = (planetA.longitude + planetA.speed * 0.1 + 360) % 360;
-                    const futureLongitudeB = (planetB.longitude + planetB.speed * 0.1 + 360) % 360;
-                    const futureAngle = this.ephem.calculateAspectAngle(futureLongitudeA, futureLongitudeB);
-                    const futureOrb = Math.abs(futureAngle - aspect.angle);
-                    aspects.push({
-                        id: `${date}:${planetA.planet}-${aspect.name}-${planetB.planet}`,
-                        planetA: planetA.planet,
-                        planetB: planetB.planet,
-                        aspect: aspect.name,
-                        orb: Number.parseFloat(orb.toFixed(2)),
-                        isApplying: futureOrb < orb,
-                        longitudeA: planetA.longitude,
-                        longitudeB: planetB.longitude,
-                    });
-                }
-            }
-        }
-        return aspects.sort((a, b) => a.orb - b.orb ||
-            a.planetA.localeCompare(b.planetA) ||
-            a.planetB.localeCompare(b.planetB) ||
-            a.aspect.localeCompare(b.aspect));
-    }
-    getMundaneDay(dayUTC, timezone, transitingPlanetIds) {
-        const localDay = utcToLocal(dayUTC, timezone);
-        const dateLabel = `${localDay.year}-${String(localDay.month).padStart(2, '0')}-${String(localDay.day).padStart(2, '0')}`;
-        const currentJD = this.ephem.dateToJulianDay(dayUTC);
-        const positions = this.ephem.getAllPlanets(currentJD, transitingPlanetIds);
-        const aspects = this.getMundaneAspects(dateLabel, positions);
-        return {
-            date: dateLabel,
-            timezone,
-            positions,
-            aspects,
-            weather: this.getMundaneWeather(aspects),
-        };
-    }
+        return this.transitService.getTransits(natalChart, input);
+    }
+    /**
+     * Produce deterministic electional context for a single local instant.
+     *
+     * @remarks
+     * Electional local times keep strict DST rejection semantics for ambiguous or
+     * nonexistent wall-clock instants.
+     */
     getElectionalContext(input) {
-        if (input.latitude < -90 || input.latitude > 90) {
-            throw new Error(`Invalid latitude: ${input.latitude} (must be between -90 and 90)`);
-        }
-        if (input.longitude < -180 || input.longitude > 180) {
-            throw new Error(`Invalid longitude: ${input.longitude} (must be between -180 and 180)`);
-        }
-        const houseSystem = input.house_system ?? 'P';
-        if (!ELECTIONAL_CONTEXT_HOUSE_SYSTEMS.includes(houseSystem)) {
-            throw new Error(`Invalid house_system: ${houseSystem} (must be one of ${ELECTIONAL_CONTEXT_HOUSE_SYSTEMS.join(', ')})`);
-        }
-        const includeRulerBasics = input.include_ruler_basics ?? false;
-        const includePlanetaryApplications = input.include_planetary_applications ?? true;
-        const orbDegrees = input.orb_degrees ?? 3;
-        if (!Number.isFinite(orbDegrees) || orbDegrees < 0.1 || orbDegrees > 10) {
-            throw new Error(`Invalid orb_degrees: ${orbDegrees} (must be between 0.1 and 10)`);
-        }
-        const parsedDate = parseDateOnlyInput(input.date);
-        const parsedTime = parseTimeOnlyInput(input.time);
-        let instantUtc;
-        try {
-            instantUtc = localToUTC({
-                year: parsedDate.year,
-                month: parsedDate.month,
-                day: parsedDate.day,
-                hour: parsedTime.hour,
-                minute: parsedTime.minute,
-                second: parsedTime.second,
-            }, input.timezone, 'reject');
-        }
-        catch (error) {
-            if (error instanceof RangeError) {
-                throw new Error(`Invalid local electional time: ${input.date} ${input.time} in ${input.timezone} is ambiguous or nonexistent due to a DST transition.`);
-            }
-            throw error;
-        }
-        const jdUt = this.ephem.dateToJulianDay(instantUtc);
-        const houses = this.houseCalc.calculateHouses(jdUt, input.latitude, input.longitude, houseSystem);
-        const positions = this.ephem.getAllPlanets(jdUt, ELECTIONAL_CONTEXT_PLANET_IDS);
-        const sun = positions.find((position) => position.planet === 'Sun');
-        const moon = positions.find((position) => position.planet === 'Moon');
-        if (!sun || !moon) {
-            throw new Error('Ephemeris failed to compute Sun/Moon positions for electional context.');
-        }
-        const sunHorizontal = this.ephem.getHorizontalCoordinates(jdUt, sun, input.longitude, input.latitude);
-        const sunAltitudeDegrees = Number.parseFloat(sunHorizontal.trueAltitude.toFixed(2));
-        const isDayChart = sunAltitudeDegrees >= 0;
-        const applyingAspects = includePlanetaryApplications
-            ? this.getElectionalApplyingAspects(positions, orbDegrees)
-            : undefined;
-        const moonApplyingAspects = applyingAspects?.filter((aspect) => aspect.from_body === 'Moon' || aspect.to_body === 'Moon');
-        const phaseAngle = Number.parseFloat(((((moon.longitude - sun.longitude) % 360) + 360) % 360).toFixed(2));
-        const warnings = [];
-        if (Math.abs(sunAltitudeDegrees) < 0.5) {
-            warnings.push('Sun is near the horizon; day/night classification is close to the boundary.');
-        }
-        warnings.push('Moon void-of-course is deferred in this slice and returns null.');
-        if (houses.system !== houseSystem) {
-            warnings.push(`House calculation fell back from ${houseSystem} to ${houses.system} for this location.`);
-        }
-        const ascLongitude = ((houses.ascendant % 360) + 360) % 360;
-        const ascSign = ZODIAC_SIGNS[Math.floor(ascLongitude / 30)];
-        const response = {
-            input: {
-                date: input.date,
-                time: input.time,
-                timezone: input.timezone,
-                latitude: input.latitude,
-                longitude: input.longitude,
-                house_system: houses.system,
-                instant_utc: instantUtc.toISOString(),
-                jd_ut: Number.parseFloat(jdUt.toFixed(8)),
-            },
-            ascendant: {
-                longitude: Number.parseFloat(ascLongitude.toFixed(4)),
-                sign: ascSign,
-                degree_in_sign: Number.parseFloat((ascLongitude % 30).toFixed(4)),
-            },
-            sect: {
-                is_day_chart: isDayChart,
-                sun_altitude_degrees: sunAltitudeDegrees,
-                classification: isDayChart ? 'day' : 'night',
-            },
-            moon: {
-                longitude: Number.parseFloat(moon.longitude.toFixed(4)),
-                sign: moon.sign,
-                phase_angle: phaseAngle,
-                phase_name: this.getElectionalPhaseName(phaseAngle),
-                is_void_of_course: null,
-                ...(moonApplyingAspects !== undefined ? { applying_aspects: moonApplyingAspects } : {}),
-            },
-            meta: {
-                deterministic: true,
-                requires_natal: false,
-                warnings,
-                deferred_features: [
-                    'robust_void_of_course',
-                    'detailed_ruler_condition',
-                    'house_context',
-                    'natal_overlays',
-                ],
-            },
-        };
-        if (applyingAspects) {
-            response.applying_aspects = applyingAspects;
-        }
-        if (includeRulerBasics) {
-            const rulerBody = this.getTraditionalSignRuler(ascSign);
-            const rulerPosition = positions.find((position) => position.planet === rulerBody);
-            if (!rulerPosition) {
-                throw new Error(`Ephemeris failed to compute ASC ruler position for ${rulerBody}.`);
-            }
-            response.ruler_basics = {
-                asc_sign_ruler: {
-                    body: rulerBody,
-                    longitude: Number.parseFloat(rulerPosition.longitude.toFixed(4)),
-                    sign: rulerPosition.sign,
-                    speed: Number.parseFloat(rulerPosition.speed.toFixed(6)),
-                    is_retrograde: rulerPosition.isRetrograde,
-                },
-            };
-        }
-        const humanText = [
-            `Electional context for ${input.date} ${input.time} (${input.timezone})`,
-            '',
-            `Ascendant: ${response.ascendant.degree_in_sign.toFixed(2)}° ${response.ascendant.sign}`,
-            `Sect: ${response.sect.classification} (${response.sect.sun_altitude_degrees.toFixed(2)}° Sun altitude)`,
-            `Moon: ${response.moon.phase_name} in ${response.moon.sign} (${response.moon.phase_angle.toFixed(2)}° phase angle)`,
-        ];
-        if (includePlanetaryApplications) {
-            const topLevelAspectText = applyingAspects && applyingAspects.length > 0
-                ? applyingAspects
-                    .slice(0, 5)
-                    .map((aspect) => `${aspect.from_body} ${aspect.aspect} ${aspect.to_body} (${aspect.orb.toFixed(2)}°)`)
-                    .join('\n')
-                : 'No applying aspects found within the configured orb.';
-            humanText.push('', 'Applying Aspects:', topLevelAspectText);
-        }
-        if (response.ruler_basics) {
-            humanText.push('', `ASC Ruler: ${response.ruler_basics.asc_sign_ruler.body} in ${response.ruler_basics.asc_sign_ruler.sign} (${response.ruler_basics.asc_sign_ruler.longitude.toFixed(2)}°)`);
-        }
-        if (warnings.length > 0) {
-            humanText.push('', `Warnings: ${warnings.join(' ')}`);
-        }
-        return {
-            data: response,
-            text: humanText.join('\n'),
-        };
-    }
+        return this.electionalService.getElectionalContext(input);
+    }
+    /**
+     * Calculate house cusps and angles for a natal chart.
+     *
+     * @remarks
+     * House-system resolution still respects explicit per-call input, then stored
+     * chart preference, then startup defaults.
+     */
     getHouses(natalChart, input = {}) {
-        const system = this.resolveHouseSystem(natalChart, input.system);
-        if (!natalChart.julianDay) {
-            throw new Error('Natal chart is missing julianDay. Re-run set_natal_chart to fix.');
-        }
-        const houses = this.houseCalc.calculateHouses(natalChart.julianDay, natalChart.location.latitude, natalChart.location.longitude, system);
-        const humanLines = houses.cusps
-            .slice(1)
-            .map((deg, i) => {
-            const sign = ZODIAC_SIGNS[Math.floor(deg / 30)];
-            return `House ${i + 1}: ${(deg % 30).toFixed(2)}° ${sign}`;
-        })
-            .join('\n');
-        const humanText = `Houses (${houses.system}):\nAsc: ${houses.ascendant.toFixed(2)}° | MC: ${houses.mc.toFixed(2)}°\n\n${humanLines}`;
-        return {
-            data: houses,
-            text: humanText,
-        };
-    }
+        return this.natalService.getHouses(natalChart, input);
+    }
+    /**
+     * Find rising-sign windows across a calendar day at a specific location.
+     *
+     * @remarks
+     * `exact` mode refines sign boundaries more aggressively; `approximate` mode
+     * keeps the cheaper bucketed scan behavior.
+     */
     getRisingSignWindows(input) {
-        const mode = input.mode ?? 'approximate';
-        if (mode !== 'approximate' && mode !== 'exact') {
-            throw new Error(`Invalid mode: ${mode} (must be approximate or exact)`);
-        }
-        if (input.latitude < -90 || input.latitude > 90) {
-            throw new Error(`Invalid latitude: ${input.latitude} (must be between -90 and 90)`);
-        }
-        if (input.longitude < -180 || input.longitude > 180) {
-            throw new Error(`Invalid longitude: ${input.longitude} (must be between -180 and 180)`);
-        }
-        const parsed = parseDateOnlyInput(input.date);
-        try {
-            utcToLocal(new Date(), input.timezone);
-        }
-        catch {
-            throw new Error(`Invalid timezone: ${input.timezone}`);
-        }
-        const dayStartLocal = {
-            year: parsed.year,
-            month: parsed.month,
-            day: parsed.day,
-            hour: 0,
-            minute: 0,
-            second: 0,
-        };
-        const dayStartUtc = localToUTC(dayStartLocal, input.timezone);
-        const dayEndUtc = addLocalDays(dayStartLocal, input.timezone, 1);
-        const getAscSign = (date) => {
-            const jd = this.ephem.dateToJulianDay(date);
-            const houses = this.houseCalc.calculateHouses(jd, input.latitude, input.longitude, 'P');
-            const normalized = ((houses.ascendant % 360) + 360) % 360;
-            return { sign: ZODIAC_SIGNS[Math.floor(normalized / 30)], longitude: normalized };
-        };
-        const refineBoundary = (left, right) => {
-            const leftSign = getAscSign(left).sign;
-            let lo = left;
-            let hi = right;
-            for (let i = 0; i < 25; i++) {
-                const mid = new Date((lo.getTime() + hi.getTime()) / 2);
-                const midSign = getAscSign(mid).sign;
-                if (midSign === leftSign) {
-                    lo = mid;
-                }
-                else {
-                    hi = mid;
-                }
-            }
-            return hi;
-        };
-        const findSignTransitionsInBucket = (start, end, probeStepMs) => {
-            const boundaries = [];
-            let probeCursor = start;
-            let currentSign = getAscSign(probeCursor).sign;
-            while (probeCursor < end) {
-                const probeNext = new Date(Math.min(probeCursor.getTime() + probeStepMs, end.getTime()));
-                const nextSign = getAscSign(probeNext).sign;
-                if (nextSign !== currentSign) {
-                    boundaries.push(mode === 'exact' ? refineBoundary(probeCursor, probeNext) : probeNext);
-                }
-                probeCursor = probeNext;
-                currentSign = nextSign;
-            }
-            return boundaries;
-        };
-        const stepMs = mode === 'exact' ? 60 * 60 * 1000 : 2 * 60 * 60 * 1000;
-        const probeStepMs = mode === 'exact' ? 5 * 60 * 1000 : 30 * 60 * 1000;
-        const boundaries = [dayStartUtc];
-        let cursor = dayStartUtc;
-        while (cursor < dayEndUtc) {
-            const next = new Date(Math.min(cursor.getTime() + stepMs, dayEndUtc.getTime()));
-            boundaries.push(...findSignTransitionsInBucket(cursor, next, probeStepMs));
-            cursor = next;
-        }
-        boundaries.push(dayEndUtc);
-        const windows = boundaries.slice(0, -1).map((start, i) => {
-            const end = boundaries[i + 1];
-            const sample = new Date((start.getTime() + end.getTime()) / 2);
-            const sign = getAscSign(sample).sign;
-            return {
-                sign,
-                start: formatLocalTimestampWithOffset(start, input.timezone),
-                end: formatLocalTimestampWithOffset(end, input.timezone),
-                durationMinutes: Math.round((end.getTime() - start.getTime()) / 60000),
-            };
-        });
-        const structuredData = {
-            date: input.date,
-            timezone: input.timezone,
-            location: {
-                latitude: input.latitude,
-                longitude: input.longitude,
-            },
-            mode,
-            windows,
-        };
-        const humanText = `Rising Sign Windows (${input.date}, ${input.timezone}, ${mode}):\n\n${windows
-            .map((window) => `${window.sign}: ${formatInTimezone(new Date(window.start), input.timezone)} → ${formatInTimezone(new Date(window.end), input.timezone)}`)
-            .join('\n')}`;
-        return {
-            data: structuredData,
-            text: humanText,
-        };
-    }
-    getElectionalApplyingAspects(positions, orbDegrees) {
-        const aspects = [];
-        for (let i = 0; i < positions.length; i++) {
-            for (let j = i + 1; j < positions.length; j++) {
-                const from = positions[i];
-                const to = positions[j];
-                const currentAngle = this.ephem.calculateAspectAngle(from.longitude, to.longitude);
-                for (const aspect of ASPECTS) {
-                    const orb = Math.abs(currentAngle - aspect.angle);
-                    if (orb > aspect.orb || orb > orbDegrees) {
-                        continue;
-                    }
-                    const applying = this.isElectionalAspectApplying(from, to, aspect.angle);
-                    if (!applying) {
-                        continue;
-                    }
-                    aspects.push({
-                        from_body: from.planet,
-                        to_body: to.planet,
-                        aspect: aspect.name,
-                        orb: Number.parseFloat(orb.toFixed(4)),
-                        applying: true,
-                    });
-                }
-            }
-        }
-        return aspects.sort((a, b) => a.orb - b.orb ||
-            a.from_body.localeCompare(b.from_body) ||
-            a.to_body.localeCompare(b.to_body) ||
-            a.aspect.localeCompare(b.aspect));
-    }
-    isElectionalAspectApplying(from, to, aspectAngle) {
-        const signedSeparation = this.getSignedAngularDifference(from.longitude, to.longitude);
-        const currentSeparation = Math.abs(signedSeparation);
-        if (currentSeparation === aspectAngle) {
-            return false;
-        }
-        const separationRate = Math.sign(signedSeparation || 1) * (to.speed - from.speed);
-        if (separationRate === 0) {
-            return false;
-        }
-        return currentSeparation < aspectAngle ? separationRate > 0 : separationRate < 0;
-    }
-    getSignedAngularDifference(fromLongitude, toLongitude) {
-        const normalized = ((toLongitude - fromLongitude + 540) % 360) - 180;
-        return normalized === -180 ? 180 : normalized;
-    }
-    getElectionalPhaseName(phaseAngle) {
-        if (phaseAngle < 45)
-            return 'new';
-        if (phaseAngle < 90)
-            return 'crescent';
-        if (phaseAngle < 135)
-            return 'first_quarter';
-        if (phaseAngle < 180)
-            return 'gibbous';
-        if (phaseAngle < 225)
-            return 'full';
-        if (phaseAngle < 270)
-            return 'disseminating';
-        if (phaseAngle < 315)
-            return 'last_quarter';
-        return 'balsamic';
-    }
-    getTraditionalSignRuler(sign) {
-        const signRulers = {
-            Aries: 'Mars',
-            Taurus: 'Venus',
-            Gemini: 'Mercury',
-            Cancer: 'Moon',
-            Leo: 'Sun',
-            Virgo: 'Mercury',
-            Libra: 'Venus',
-            Scorpio: 'Mars',
-            Sagittarius: 'Jupiter',
-            Capricorn: 'Saturn',
-            Aquarius: 'Saturn',
-            Pisces: 'Jupiter',
-        };
-        return signRulers[sign] ?? 'Mars';
+        return this.risingSignService.getRisingSignWindows(input);
     }
+    /**
+     * Return the currently retrograde planets for the requested reporting timezone.
+     */
     getRetrogradePlanets(timezone) {
-        const resolvedTimezone = this.resolveReportingTimezone(timezone);
-        const now = this.now();
-        const jd = this.ephem.dateToJulianDay(now);
-        const allPlanetIds = Object.values(PLANETS);
-        const positions = this.ephem.getAllPlanets(jd, allPlanetIds);
-        const retrograde = positions.filter((p) => p.isRetrograde);
-        const localNow = utcToLocal(now, resolvedTimezone);
-        const dateLabel = `${localNow.year}-${String(localNow.month).padStart(2, '0')}-${String(localNow.day).padStart(2, '0')}`;
-        const structuredData = {
-            date: dateLabel,
-            timezone: resolvedTimezone,
-            planets: retrograde,
-        };
-        const humanText = retrograde.length === 0
-            ? 'No planets are currently retrograde.'
-            : `Retrograde Planets:\n\n${retrograde.map((p) => `${p.planet}: ${p.degree.toFixed(2)}° ${p.sign}`).join('\n')}`;
-        return { data: structuredData, text: humanText };
-    }
+        return this.skyService.getRetrogradePlanets(timezone);
+    }
+    /**
+     * Return the next rise and set events after the local day anchor for the chart location.
+     *
+     * @remarks
+     * The lookup anchor remains local midnight in the natal chart timezone even
+     * when reporting text uses a preferred reporting timezone.
+     */
     async getRiseSetTimes(natalChart) {
-        const timezone = natalChart.location.timezone;
-        const reportingTimezone = this.mcpStartupDefaults.preferredTimezone || timezone;
-        const now = this.now();
-        const localNow = utcToLocal(now, timezone);
-        const localMidnight = {
-            year: localNow.year,
-            month: localNow.month,
-            day: localNow.day,
-            hour: 0,
-            minute: 0,
-            second: 0,
-        };
-        const midnightUTC = localToUTC(localMidnight, timezone);
-        const dateLabel = `${localNow.year}-${String(localNow.month).padStart(2, '0')}-${String(localNow.day).padStart(2, '0')}`;
-        const results = await this.riseSetCalc.getAllRiseSet(midnightUTC, natalChart.location.latitude, natalChart.location.longitude);
-        const structuredData = {
-            date: dateLabel,
-            timezone,
-            times: results.map((r) => ({
-                planet: r.planet,
-                rise: r.rise?.toISOString() ?? null,
-                set: r.set?.toISOString() ?? null,
-            })),
-        };
-        const humanText = `Rise/Set Times:\n\n${results
-            .map((r) => {
-            const rise = r.rise ? this.formatTimestamp(r.rise, reportingTimezone) : 'none';
-            const set = r.set ? this.formatTimestamp(r.set, reportingTimezone) : 'none';
-            return `${r.planet}: Rise ${rise}, Set ${set}`;
-        })
-            .join('\n')}`;
-        return {
-            data: structuredData,
-            text: humanText,
-        };
+        return this.skyService.getRiseSetTimes(natalChart);
     }
+    /**
+     * Return current asteroid and node positions for the requested reporting timezone.
+     */
     getAsteroidPositions(timezone) {
-        const resolvedTimezone = this.resolveReportingTimezone(timezone);
-        const now = this.now();
-        const jd = this.ephem.dateToJulianDay(now);
-        const asteroidIds = [...ASTEROIDS, ...NODES];
-        const positions = this.ephem.getAllPlanets(jd, asteroidIds);
-        const localNow = utcToLocal(now, resolvedTimezone);
-        const dateLabel = `${localNow.year}-${String(localNow.month).padStart(2, '0')}-${String(localNow.day).padStart(2, '0')}`;
-        const structuredData = {
-            date: dateLabel,
-            timezone: resolvedTimezone,
-            positions,
-        };
-        const humanText = `Asteroid & Node Positions:\n\n${positions
-            .map((p) => {
-            const rx = p.isRetrograde ? ' Rx' : '';
-            return `${p.planet}: ${p.degree.toFixed(2)}° ${p.sign}${rx}`;
-        })
-            .join('\n')}`;
-        return {
-            data: structuredData,
-            text: humanText,
-        };
+        return this.skyService.getAsteroidPositions(timezone);
     }
+    /**
+     * Look up the next solar and lunar eclipses after the current instant.
+     */
     getNextEclipses(timezone) {
-        const resolvedTimezone = this.resolveReportingTimezone(timezone);
-        const now = this.now();
-        const jd = this.ephem.dateToJulianDay(now);
-        const solarEclipse = this.eclipseCalc.findNextSolarEclipse(jd);
-        const lunarEclipse = this.eclipseCalc.findNextLunarEclipse(jd);
-        const eclipses = [];
-        const humanLines = [];
-        if (solarEclipse) {
-            eclipses.push({
-                type: solarEclipse.type,
-                eclipseType: solarEclipse.eclipseType,
-                maxTime: solarEclipse.maxTime.toISOString(),
-            });
-            humanLines.push(`Next Solar Eclipse: ${this.formatTimestamp(solarEclipse.maxTime, resolvedTimezone)} (${solarEclipse.eclipseType})`);
-        }
-        if (lunarEclipse) {
-            eclipses.push({
-                type: lunarEclipse.type,
-                eclipseType: lunarEclipse.eclipseType,
-                maxTime: lunarEclipse.maxTime.toISOString(),
-            });
-            humanLines.push(`Next Lunar Eclipse: ${this.formatTimestamp(lunarEclipse.maxTime, resolvedTimezone)} (${lunarEclipse.eclipseType})`);
-        }
-        const structuredData = { timezone: resolvedTimezone, eclipses };
-        const humanText = eclipses.length === 0
-            ? 'No eclipses found in the near future.'
-            : `Upcoming Eclipses:\n\n${humanLines.join('\n')}`;
-        return { data: structuredData, text: humanText };
+        return this.skyService.getNextEclipses(timezone);
     }
+    /**
+     * Summarize process-local server state and configured startup defaults.
+     */
     getServerStatus(natalChart) {
-        const statusData = {
-            serverVersion: '1.0.0',
-            hasNatalChart: natalChart !== null,
-            natalChartName: natalChart?.name ?? null,
-            natalChartTimezone: natalChart?.location.timezone ?? null,
-            startupDefaults: {
-                preferredTimezone: this.mcpStartupDefaults.preferredTimezone ?? null,
-                preferredHouseStyle: this.mcpStartupDefaults.preferredHouseStyle ?? null,
-                weekdayLabels: this.mcpStartupDefaults.weekdayLabels ?? null,
-            },
-            ephemerisInitialized: this.isInitialized(),
-            stateModel: 'stateful-per-process',
-        };
-        const humanText = natalChart
-            ? `Server ready. Natal chart loaded: ${natalChart.name} (${natalChart.location.timezone})`
-            : 'Server ready. No natal chart loaded — call set_natal_chart first.';
-        return { data: statusData, text: humanText };
-    }
+        return this.natalService.getServerStatus(natalChart);
+    }
+    /**
+     * Generate a natal chart image or SVG for the current chart.
+     *
+     * @remarks
+     * When `output_path` is omitted the payload is returned inline; otherwise the
+     * rendered asset is written to disk and only path metadata is returned.
+     */
     async generateNatalChart(natalChart, input = {}) {
-        const theme = input.theme || getDefaultTheme(natalChart.location.timezone);
-        const format = input.format || 'svg';
-        const outputPath = input.output_path;
-        const chart = await this.chartRenderer.generateNatalChart(natalChart, theme, format);
-        if (outputPath) {
-            if (format === 'svg') {
-                await this.writeFileFn(outputPath, chart, 'utf-8');
-            }
-            else {
-                await this.writeFileFn(outputPath, chart);
-            }
-            return {
-                format,
-                outputPath,
-                text: `Natal Chart for ${natalChart.name} saved to: ${outputPath}`,
-            };
-        }
-        if (format === 'svg') {
-            return {
-                format,
-                text: `Natal Chart for ${natalChart.name}:`,
-                svg: chart,
-            };
-        }
-        const base64 = chart.toString('base64');
-        const mimeType = format === 'png' ? 'image/png' : 'image/webp';
-        return {
-            format,
-            text: `Natal Chart for ${natalChart.name} (${theme} theme, ${format.toUpperCase()} format):`,
-            image: {
-                data: base64,
-                mimeType,
-            },
-        };
-    }
+        return this.chartOutputService.generateNatalChart(natalChart, input);
+    }
+    /**
+     * Generate a transit chart image or SVG for a target date.
+     *
+     * @remarks
+     * Omitted dates still resolve to local noon in the natal chart timezone before
+     * rendering so date-only behavior stays stable across timezone conversions.
+     */
     async generateTransitChart(natalChart, input = {}) {
-        const dateStr = input.date;
-        const theme = input.theme ?? getDefaultTheme(natalChart.location.timezone);
-        const format = input.format ?? 'svg';
-        let targetDate;
-        if (dateStr) {
-            const parsed = parseDateOnlyInput(dateStr);
-            targetDate = localToUTC(parsed, natalChart.location.timezone);
-        }
-        else {
-            const now = this.now();
-            const localNow = utcToLocal(now, natalChart.location.timezone);
-            const localNoon = { ...localNow, hour: 12, minute: 0, second: 0 };
-            targetDate = localToUTC(localNoon, natalChart.location.timezone);
-        }
-        const outputPath = input.output_path;
-        const chart = await this.chartRenderer.generateTransitChart(natalChart, targetDate, theme, format);
-        const dateLabel = formatDateOnly(targetDate, natalChart.location.timezone);
-        if (outputPath) {
-            if (format === 'svg') {
-                await this.writeFileFn(outputPath, chart, 'utf-8');
-            }
-            else {
-                await this.writeFileFn(outputPath, chart);
-            }
-            return {
-                format,
-                outputPath,
-                text: `Transit Chart for ${natalChart.name} (${dateLabel}) saved to ${outputPath}`,
-            };
-        }
-        if (format === 'svg') {
-            return {
-                format,
-                text: `Transit Chart for ${natalChart.name} (${dateLabel})`,
-                svg: chart,
-            };
-        }
-        const base64 = chart.toString('base64');
-        const mimeType = format === 'png' ? 'image/png' : 'image/webp';
-        return {
-            format,
-            text: `Transit Chart for ${natalChart.name} (${dateLabel}, ${theme} theme, ${format.toUpperCase()} format):`,
-            image: {
-                data: base64,
-                mimeType,
-            },
-        };
+        return this.chartOutputService.generateTransitChart(natalChart, input);
     }
 }