The email said the two hard parts are "various hardware devices" and "priorities". This is the priorities half. ACP is what small observatories have run for twenty years and DC-3 Dreams no longer supports it, so the scheduler is replicated rather than invented: an operator moving across should meet the behaviour they already know. The source is Denny, "Dispatch Scheduling of Automated Telescopes", Proc. Society for Astronomical Sciences 23, p.35 (2004), which adapts Steele & Carter, Proc. SPIE 3112, p.222 (1997). services/observability.js is the geometry: sidereal time, precession, alt/az, Kasten-Young airmass, Sun and Moon, twilight bands, visibility windows, and constraint evaluation that gives a reason for every refusal. Low precision on purpose, and the header says where it must not be used: pointing needs refraction and nutation, timing needs the barycentric correction the sidecar already does with astropy. services/dispatch.js is the scheduler. The six-term efficiency function with the coefficients the paper reports as working (priority 1.0, transit 0.8, slew 0.7), per-user priority normalisation to a mean of 0.5, the Lorentzian moon-avoidance distance, the four-value sky quality scale, and the rule that a running plan is never abandoned for a better unstarted one. Two of those terms are worth the words they cost. Nearness to transit is altitude over the target's OWN transit altitude, not over 90, because dividing by 90 rewards a target for the accident of having a declination near the observatory's latitude. Slew overhead is a fraction of observing time rather than a distance penalty, because thirty seconds of slew is nothing before an hour of integration and everything before a ten-second exposure. The tests assert the paper's own findings: weighting priority alone picks the most important target wherever it is, transit alone tracks the meridian, slew alone walks the sky in short hops. If those do not reproduce, it is not the same scheduler however plausible the output. One real bug, found only because the ephemeris is checked against astropy at three sites and four epochs rather than against itself: the first version fed J2000 catalogue coordinates into an of-date hour angle. That is a frame mismatch, and it put every altitude 0.37 degrees out in the same direction, which is precisely the error a self- consistent test suite cannot see. Precession to the equinox of date fixed it, and the module now takes and returns J2000 throughout. Two test expectations of mine were also wrong and are corrected rather than accommodated: a target 70 degrees east at declination 10 is below the altitude limit and never competed at all, and with the published weights a nine-fold priority edge is SUPPOSED to carry a 25-degree slew, which is what the paper describes. 319 server tests. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
35 KiB
Caelum + Nox TODOs
Outstanding work from the DX review on 2026-05-14 (commit dc6c460). Each entry includes what/why/pros/cons/context so anyone can pick it up cold.
Shipped since the review: A (real-mode confirm), B (in-IDE hardware wizard), C (CLI verbose-by-default), D (error fix suggestions + doc anchors), E (docs full-text search), F (docker-compose self-host), G (VSCode extension), H (Alpaca driver translation for Nox), I (Report a problem link), J (SQLite backend), K (DB-outage resilience). See CHANGELOG.md for details.
Remaining from the original DX review: none. All eleven items shipped.
Strategic call still open (deferred during H): full INDI (Linux native binary) and ASCOM-over-COM (Windows-only) support beyond what Alpaca reaches. Alpaca is the modern bridge and covers most contemporary gear; INDI/ASCOM-native are out of scope until there's a real user with hardware that requires them.
A second backlog starts at L. Items A through K came out of the DX review and are about making Caelum pleasant to run. L onward come from a different question, asked 2026-09-12: what would make Caelum a platform research actually gets done on, rather than an operations tool with an image gallery attached. Same format, same "pick it up cold" rule. Code comments reference these by letter, so the letters are stable once assigned.
K. DB-outage resilience
What: Today the server hard-exits when MySQL becomes unreachable. initDb() rejects with ECONNREFUSED and the process dies, which under restart: unless-stopped triggers a tight restart loop. Same thing happens if MySQL is temporarily slow or rebooting.
Why: Caught during the live docker-compose smoke test (commit shipping K's note). Stopping the db container caused the app container to restart-loop instead of going temporarily-degraded. With the enriched /api/health returning 503 on DB-down, the right behavior is: app stays alive, healthcheck reports degraded, load balancer/proxy drains, app reconnects when the DB recovers.
Pros: Production-grade resilience. Rolling MySQL restarts no longer require restarting Caelum. Compounds with the docker-compose self-host story (F).
Cons: Requires retry semantics across all DB-touching code paths, not just initDb. mysql2 pools have reconnect logic but background services (weather sim, lifecycle) may not handle transient errors.
Context: server/src/index.js initDb() is fatal on error. The right shape is: if initDb fails, log + start serving with /api/health returning 503; retry initDb in the background until it succeeds. Background services (startWeatherSim, startLifecycle) need to wrap queries in try/catch and skip ticks on error rather than crashing.
J. SQLite as default DB
What: Make SQLite the default database. Caelum boots cold without a MySQL install. MySQL becomes the production self-host path, controlled by an env var.
Why: The MySQL install gate is the single largest TTHW killer. The outside-voice cross-model review caught this: SQLite was the original DB before the MySQL migration. Restoring it for first-run experience compresses ~25 minutes of setup into zero.
Pros: Eliminates docker-compose need (item F). Reaches Champion TTHW tier. New users can npm run dev immediately after clone.
Cons: Multi-hour refactor:
- DDL block in
server/src/config/database.jsuses MySQL-specific syntax (ENGINE=InnoDB,AUTO_INCREMENT,utf8mb4, backtick-quoted reserved words) that needs a parallel SQLite DDL or a transpiler addColumnIfMissingqueriesINFORMATION_SCHEMA- needs SQLite'sPRAGMA table_infoequivalentmysql2typeCast hook for DATETIME → ISO-8601 needs a SQLite equivalent (better-sqlite3 returns strings already, but format differs)- Transaction helper differs (begin/commit/rollback vs mysql2's
getConnection().beginTransaction()) - Many routes use MySQL-only features (e.g., ON DUPLICATE KEY UPDATE, backtick-quoted column names like
\dec``). Each route's SQL needs ANSI-compatible variants. - The seed.js and migrate.js scripts already cross both, so partial reuse is possible
- Tests need to run against both DB types in CI
Context: All the SQL lives in server/src/config/database.js (DDL) and server/src/routes/*.js (individual queries). better-sqlite3 is already in server/package.json dependencies. The legacy SQLite path that existed before the MySQL migration was removed, so restoring it means building a fresh adapter, not reviving old code.
Estimate: 4-8 hours of careful work plus a full QA pass on every route. Worth doing in a dedicated session.
Blocked by: Nothing technical. Just session capacity.
A. Real-mode confirmation dialog with op preview
What: When IDE Mode = "Real hardware" and the user clicks Run, show a dialog: "This will issue N hardware operations against Telescope X. First op: slew to Coord(...). Confirm?" Op count and first op come from running the program in mock mode first.
Why: Currently a single click on Real-mode Run can issue arbitrary Stellarium packets to whatever telescope row matches the resource name. A backyard astronomer at 2 AM is exactly the wrong audience for "oops, I parked into the dome wall."
Pros: Prevents the worst category of mistakes. Free safety net. Cons: Adds friction for power users (mitigate with "don't ask again this session" checkbox).
Context: Mode picker is in client/src/views/Nox.vue header. Running in mock to derive the preview reuses the existing /api/nox/run (mock mode) endpoint.
Blocked by: Item H (no real driver layer means no real consequences to prevent yet).
B. In-IDE "Connect my hardware" wizard
What: Inline 3-step wizard inside the IDE that creates a Site + Enclosure + Telescope and pre-fills the Nox program's use telescope T = "<name>" with the new name.
Why: Today: user runs example 01 in mock, decides to point at their real scope, has to leave /nox for /sites, create three nested entities through forms, return, rewrite. Five context switches before they can slew.
Pros: Closes the gap between mock and real that the dual persona's network-operator side needs. Cons: Tied to whatever real driver story exists (INDI/ASCOM/Alpaca). Without that, the wizard creates fake rows.
Context: Site/Enclosure/Telescope schema is in sql/app.sql (live tables) and routes are at server/src/routes/{sites,configdb}.js.
Blocked by: Item H.
C. CLI verbose-by-default + --quiet flag
What: nox run example.nox becomes verbose-by-default (streams every op, prints final count). --quiet switches to current summary-only behavior.
Why: The backyard-astronomer persona expects to see what's happening, not get a count. Today they have to discover nox ops to see the stream.
Pros: Small change. Matches the persona's mental model.
Cons: Breaks anyone scripting against the current 2 ops output. Pre-1.0 SemVer covers this.
Context: nox/runtime/bin/nox.js. Add parseArgs for --quiet. Keep nox ops as alias.
D. Error fix suggestions + doc anchors
What: Type-check diagnostics gain a suggest field and a seeAlso doc anchor.
2:1 arg 1 (amount): expected Angle, got Duration
suggest: try 30arcsec or 30arcmin instead of 30s
see also: reference/types.md#angle
Why: Current diagnostics are good (line:col + message) but stop short of Elm-tier empathy. The checker already has the dimension info needed to suggest the right unit.
Pros: Compounds with docs. Every error becomes a learning moment. Cons: Maintenance burden (every new diagnostic needs a suggest + anchor mapping).
Context: Checker is at nox/parser/src/checker.js. Diagnostics are emitted via diag(). Extend the shape to include suggest?: string and seeAlso?: string.
E. Docs search (minisearch)
What: Client-side search index built at SPA build time. Search box in /nox/docs and /nox topbar.
Why: 20 doc files split across book/ and reference/. Users looking for "how do I dither" have to skim. Search starts to matter past ~20 docs and is critical past ~50.
Pros: Works offline, no external dependency, ~150 KB added to docs bundle. Cons: Index goes stale if docs change without rebuild. Minisearch is small but adds complexity.
Context: Build step would run at vite build time, write client/src/views/nox/docs-index.json. NoxDocs.vue gains a <input type="search"> and calls minisearch.search on the in-memory index.
F. docker-compose.yml for production self-host
What: Compose file with mysql:8, caelum-server, caelum-client services. docker compose up boots the whole stack.
Why: With SQLite as the default, MySQL is the production path. Production users want one command, not a five-step install + grant flow.
Pros: Single command setup for self-hosters. Easy to run in CI for integration tests. Cons: Maintenance burden. Compose file drift is common.
Context: Need a Dockerfile for server and client first. Server is straightforward (node:22-alpine + npm install). Client is a build-time concern; serves dist statically through the server. Compose file lives at repo root.
G. VSCode extension with .nox TextMate grammar
What: Ship a minimal extension that adds syntax highlighting for .nox files in VSCode and OpenVSX.
Why: Today the only highlighter is the CodeMirror mode inside the web IDE. Users editing .nox files in VSCode see plain text.
Pros: Compounds with every .nox file ever written. Low maintenance once shipped. Cons: Publishing to the VSCode marketplace requires a Microsoft account; OpenVSX is the open-source alternative.
Context: TextMate grammar can be derived from the CodeMirror tokens at client/src/views/nox/language.js. Extension scaffold via yo code. Publish via vsce publish or ovsx publish.
H. Driver layer for INDI / ASCOM / Alpaca
What: Real telescope and dome driver bindings, not just the mock. Bind Nox's T.slew(target) to actual hardware via INDI (Linux/cross-platform), ASCOM (Windows), or Alpaca (REST over network).
Why: This is the real product for the network-operator persona. Mock mode is a demo. Without drivers, Nox is a typed DSL for a fictional telescope. Outside voice in DX review correctly flagged this as the missing strategic piece.
Pros: Unlocks the entire secondary persona. Makes Caelum a credible alternative to NINA/SGP/Ekos for shared-fleet operators. Cons: Multi-week scope. Hardware testing required. Per-driver protocol quirks (ASCOM is COM-based on Windows only, INDI is a TCP protocol with its own XML, Alpaca is REST).
Context: Existing server/src/services/external-drivers.js and telescope-control.js have partial bits (Stellarium protocol for slew, alpacaPut helpers, INDI is not wired). Real driver factory in server/src/services/nox-driver.js already has hooks; methods just log without effect for non-slew ops today.
Strategic decision needed first: Should Nox stay as Caelum's DSL, or should Caelum be a thin orchestrator over INDI/ASCOM with YAML sequences instead of a custom DSL? Outside voice raised this; review didn't resolve it. Worth a /office-hours or /plan-ceo-review session before scoping H.
I. Pre-filled "Report a problem" link in IDE topbar
What: Click → opens GitLab issue prefilled with: Nox version, current program text (or "No program loaded"), last 20 ops, last diagnostic. User adds the "what happened" line and submits.
Why: Capture real bugs cheaply. Today a confused user types the error into Google, finds nothing, files no issue, and you never learn it happened.
Pros: Smallest viable feedback path. One issue tracked is worth a hundred lost. Cons: Premature without users. Worth landing after the first non-maintainer signs up.
Context: GitLab supports ?issue[title]=...&issue[description]=... query parameters for prefilled new-issue URLs. Build the URL client-side from the current IDE state.
Research platform
Caelum today is strong on operations (publish a telescope, book it, run the session, keep the frames) and thin on science (nothing produces a calibrated measurement). These items close that gap. They are ordered by dependency, not by appeal.
Two decisions are already made and constrain everything below.
The reduction pipeline comes first. Photometry, time-domain science, interoperability and citation all stand on calibrated frames with a valid WCS. Building any of them on unreduced data means redoing them.
Pixel work happens in a Python sidecar. astropy, photutils, SEP, ccdproc
and a plate solver are validated and widely trusted. A bug in a hand-rolled
aperture sum produces plausible wrong answers, which is the worst failure mode
available to a science platform. Node keeps the domain logic, the queue and the
provenance; the sidecar does the arithmetic. See services/reduction-queue.js
for the claim protocol a sidecar worker uses.
Two items are not phases but constraints on every phase: N (uncertainties) and O (time standards) must land with the code that produces the numbers, because retrofitting an error bar means recomputing every measurement that lacks one.
L. Reduction pipeline, phases 2 to 5
What: Finish the pipeline phase 1 scaffolded. Phase 2: the Python sidecar plus master bias/dark/flat construction and calibrated frame products. Phase 3: plate solving into a stored WCS, and source extraction. Phase 4: aperture and differential photometry. Phase 5: the UI surfaces for all of it.
Why: Phase 1 shipped the queue, the provenance model, the header stage and
the calibration matching rules, and nothing that touches a pixel. calibrate,
astrometry, extract, photometry and timing are registered stages with
no worker, so they sit pending and a frame reports partial. That is the
intended state, not a bug, but it is also the state where the platform produces
no measurements.
Pros: Unblocks every other item in this section. The seam already exists, so this is filling in behind a stable interface rather than redesigning. Cons: A new deployable in the compose stack, with its own image, its own Python dependency tree, and its own failure modes. Plate solver index files are the awkward part: astrometry.net's full index set runs to tens of GB. Plan for ASTAP or a bounded index range matched to the fleet's actual plate scales, with a hosted solver as the dev fallback.
Context: server/src/services/reduction-queue.js
defines the stages and the conditional-UPDATE claim. A sidecar worker claims
with local: false, does the work, and calls completeJob with a result that
merges into reduction_runs.stages_json. Calibration grouping and master
selection are already implemented and tested in
server/src/services/calibration.js, so the
sidecar is told which masters to apply rather than deciding.
Estimate: Phase 2 is a substantial session on its own. Phases 3 and 4 each similar. Worth doing one phase per session with a QA pass between.
Progress (2026-09-12):
- The worker protocol is done and tested:
routes/reduction-worker.js, 10 endpoints, behind areduction-scoped token that is deliberately not account-wide write. See docs/reduction-worker-protocol.md. sidecar/exists with three stages implemented and 154 tests:timing.py(UTC to BJD_TDB at mid-exposure, which is also item O),calibrate.py(master bias/dark/flat, applied with uncertainties propagated, which is also item N for this stage) andextract.py(source catalogue plus frame quality, which is item P).- Phase 2 is complete. The poll loop, the protocol client, the container and
the compose entries are done, and it has been verified end to end: the real
container claims a queued
timingjob against a live API, computes BJD_TDB, reports it, and the run settlescompletewith the software versions recorded.docker compose --profile reduction up -d. - Phase 3 is half done.
extractshipped ahead ofastrometrybecause extraction can be verified on a laptop against synthetic fields with known truth, while a solver needs Gaia DR3 indexes running to tens of GB. Its dependency moved fromastrometrytocalibrate: quality metrics are measured off the pixel grid and a WCS only adds sky positions to sources already found, so the old ordering meant no frame could ever have a measured FWHM. - Source catalogues are stored.
frame_sourcesholds every detection per frame with its pixel position, sky position where the frame is solved, and instrumental flux, uploaded by the sidecar in batches to its own endpoint rather than riding in the run's provenance JSON. This was photometry's blocker. - Still to do: the astrometry and photometry stages. Astrometry needs a solver binary in the image and Gaia DR3 indexes on a volume, which is the first piece here that cannot be verified on a laptop. Photometry can now read the catalogue; differential photometry against comparison stars in the same frame needs no zero point, while anything cross-telescope needs item M.
- No CI image-build job for the sidecar yet, on purpose. The shared runner already builds one image per pipeline across nine repos, and a scientific-Python build on every push is not worth it for a service that cannot yet do the stages that matter. Add it when astrometry lands.
- SEP was dropped in favour of photutils. Same capability, pure Python over numpy so wheels exist everywhere, and it is the astropy-affiliated package we already depend on. SEP is a C extension and had no wheel for Python 3.14.
M. Cross-site photometric standardization
What: Turn instrumental magnitudes into standard-system magnitudes. Per-frame zero points, per-instrument-and-filter color terms, and transformation into a real passband (Johnson-Cousins or Sloan).
Why: This is the item that matters most, because it is what makes the federation mean anything. Caelum's differentiator against LCO is that it federates independent operators rather than one organization's homogeneous fleet. But a CDK14 with an Ha filter and an RC600 with a different sensor produce numbers that cannot be combined, so without standardization a twelve-telescope network is twelve archives that happen to share a login. Nobody can build one light curve out of it, which is the entire point.
Pros: Converts the network into a single instrument. Every downstream item (R, S, T, V) gets more valuable. It is also the thing a reviewer checks first. Cons: Needs a reference catalog with standardized photometry for arbitrary fields, and needs per-instrument characterization that has to be maintained as operators change filters and cameras. Color terms drift and go stale silently, which is the same failure shape as a stale flat.
Context: Gaia DR3 synthetic photometry makes this far more tractable than
the classical approach, because standardized comparison-star magnitudes are
available for almost any field without photometric standard fields and
all-sky nights. Store the derived zero point and its uncertainty per frame, and
the color terms against the instrument, not the frame. The existing
instruments table is the right home for the latter. Supersede rather than
overwrite, the way calibration_masters.superseded_by works, so a historical
measurement still resolves the terms it was reduced with.
Blocked by: L phase 4.
N. Uncertainties propagated end to end
What: An error bar on every derived quantity, with a documented recipe. Photon noise, read noise, dark current, flat-field error, scintillation, and zero-point uncertainty, combined and stored alongside the value.
Why: archive_frames currently has no error columns at all. A magnitude
without an uncertainty is not a measurement, and a reviewer will say so. This is
unglamorous and it is the line between data that gets cited and data that gets
ignored.
Pros: Cheap if done with the code that computes the values. Makes every product defensible. Cons: Expensive if done later, because it means recomputing everything that shipped without it. The combination recipe has to be written down and versioned along with the pipeline, or the numbers are unauditable.
Context: Not a phase. A constraint on L phases 3 and 4 and on M. The
reduction_runs.pipeline_version field is the hook for versioning the recipe.
O. Time standards: BJD_TDB
What: Barycentric Julian Date in Barycentric Dynamical Time, at mid-exposure, per frame.
Why: Anything periodic needs it: transits, eclipsing binaries, pulsating
variables. The timing stage is already registered and deliberately assigned to
the sidecar rather than Node, because the correction needs a solar-system
ephemeris to place the observatory relative to the barycentre and a JS
approximation lands around 0.1 seconds when transit timing wants better.
Pros: Small, well-bounded, and astropy does the hard part. Cons: The UTC to TDB chain plus light-travel correction is easy to get subtly wrong, and the resulting errors are periodic, so they look like signal rather than like a bug. Needs test vectors from a known source, not just "it runs".
Context: Needs the site's geodetic position, which sites already stores as
latitude, longitude and altitude, plus a reliable DATE-OBS and EXPTIME,
which the header stage now extracts. Mid-exposure, not start: store which
convention was used rather than assuming the reader knows.
Blocked by: L phase 2 (the sidecar).
P. Per-frame quality metrics
What: Seeing and FWHM, ellipticity, sky brightness, limiting magnitude, transparency, and guiding RMS, measured per frame and stored as columns.
Why: Two uses for one piece of work. Researchers get quality flags they can
filter on, which is how you exclude the frames taken through cloud without
throwing away the night. And the aggregates characterize a site, which feeds the
trust and discovery story the sites table already keeps counters for.
Pros: Falls out of source extraction almost for free once L phase 3 lands.
Directly improves the federation's existing experimental-site graduation logic.
Cons: fwhm_arcsec exists on archive_frames today and is populated from
the header when a camera happens to write it, which is inconsistent. Measured
values and header-claimed values should not share a column.
Blocked by: L phase 3.
Progress (2026-09-12): Mostly done. sidecar/caelum_reduce/extract.py
measures seeing, ellipticity, sky level, sky RMS, limiting flux and source
count, and the extract stage writes them to archive_frames as
seeing_fwhm_arcsec, seeing_fwhm_px, ellipticity, sky_adu,
sky_rms_adu, limiting_flux_adu, source_count and extracted_at. The
column-sharing concern above is settled by not sharing: fwhm_arcsec keeps
the header's claim untouched and every surface labels which of the two it is
showing. GET /api/archive filters and sorts on the measured columns
(max_seeing, max_ellipticity, min_sources, measured=1,
sort=seeing|depth|sources), which is the "quality flags researchers filter
on" half.
Still open: limiting magnitude rather than limiting flux, which needs a zero point from item M; transparency, which needs a standard star or a frame-to-frame comparison; guiding RMS, which comes from the mount rather than the pixels and has nowhere to arrive from yet; and the site aggregates that feed the experimental-site graduation logic.
Q. Virtual Observatory endpoints
What: IVOA protocol surfaces over the existing archive: TAP with ADQL for queries, Cone Search for positional lookup, SIA for images, and ObsCore as the metadata model. Register in the IVOA registry.
Why: The most payoff per hour of work in the section. It is a protocol adapter over data already stored, and the reward is that TOPCAT, Aladin and astroquery users query Caelum directly, from the tools they already use. The registry entry means people find it without being told it exists. This is the difference between an archive and a silo.
Pros: No new science, no new pipeline. Mostly mapping existing columns onto a standard schema and speaking a documented wire format. Cons: ADQL is a real query language and exposing it means exposing the database to arbitrary user queries, which needs a read-only path, result limits, timeouts, and async job support for long queries. Visibility rules have to be enforced inside the query layer, not around it, or a TAP query becomes a way to read private frames.
Context: ObsCore maps cleanly onto archive_frames once M and O land, since
it wants standardized photometry and proper time metadata. Doing Q before those
means publishing a schema with the interesting columns empty.
Blocked by: M and O, for the fields to be worth publishing.
R. Submit observations upstream
What: Report Caelum observations into the datasets professionals use. NEO astrometry to the Minor Planet Center in ADES format under an assigned observatory code. Variable star photometry to the AAVSO database. Transients to the Transient Name Server.
Why: Concrete institutional recognition, and it is achievable rather than aspirational. An MPC observatory code is a real credential. It also closes a loop Caelum already half-built: SpaceDB holds 1.5M asteroids and comets and the research feed already surfaces NEO candidates, but an observation of one currently goes nowhere.
Pros: Turns a Caelum observation into a permanent contribution. Strong motivation for operators, and a reason for a researcher to join. Cons: MPC astrometry needs sub-arcsecond positions, which means solving against Gaia DR3 rather than whatever index a solver ships with. Design for that in L phase 3 rather than retrofitting. Each destination has its own format and its own submission etiquette, and bad submissions are worse than none.
Context: server/src/routes/research.js has
the candidate feed and the category vocabulary (neo, exoplanet_transit,
variable_star) that maps onto the three destinations.
Blocked by: L phase 3 (astrometry) for MPC, M for AAVSO.
S. Citable data releases
What: Versioned data releases with DOIs through Zenodo or DataCite, standard license terms, and bibcode linking back to ADS for papers that use them.
Why: Once a paper can cite "Caelum DR1", Caelum stops being a website and
starts being infrastructure. The provenance model built in phase 1 is the hard
part of this and it already exists: a release is a frozen set of
reduction_runs plus the products they produced.
Pros: The expensive groundwork is done. Re-reducing a frame already creates a new run rather than editing the old one, specifically so a published measurement keeps pointing at what produced it. Cons: A release is a promise not to change data, which means storage policy, retention, and a deprecation story. Also a licensing decision that has to hold across federated operators who each own their frames.
Blocked by: M, N, O. A release of uncalibrated data with no error bars is not worth a DOI.
T. Alert-driven target-of-opportunity follow-up
What: An alert arrives from a broker. Caelum computes visibility across every federated site, finds the ones that can see it now, generates a Nox program, and queues the observation.
Why: The feature most likely to make Caelum matter. Small-telescope networks are good at rapid follow-up, and professional facilities are badly oversubscribed for it, so this is a real gap rather than a crowded space. It is also the item that uses the most of what Caelum already has.
Pros: Little of it is far from the current stack. Sites and visibility math partly exist already, the jobs queue is built, the observation snapshot pattern is in place, and Nox is a natural fit for generating the script. It is the clearest answer to "why would a researcher use this". Cons: Latency becomes a correctness property rather than a nicety, which changes how the queue and the daemon have to behave. Alert volume from a survey-scale stream is large and needs filtering before it reaches scheduling. It also implies a priority model, since a target of opportunity has to be able to interrupt scheduled time, which is a policy question as much as a technical one.
Context: Consume existing brokers, do not build one. ALeRCE, Fink, Lasair and ANTARES cover ZTF and Rubin; GCN over Kafka carries gamma-ray burst and gravitational-wave alerts. Visibility helpers exist in client/src/views/Research.vue and should move server-side to be reusable here.
Blocked by: U, in practice. Interrupting scheduled time needs a scheduler that understands priority.
U. Constraint-based scheduler
What: Replace slot-picking with a scheduler. Airmass and altitude limits, moon distance and phase, twilight, hour angle, cadence requirements ("every three days for six weeks"), priority from a proposal allocation, and rescheduling when weather kills a night.
Why: Schedule is currently a calendar: a user picks a slot and hopes. A research program needs the data its science requires, which is a constraint satisfaction problem, not a booking form. This is what converts "I booked time" into "the observation happened under conditions that make it usable".
Pros: Makes proposals mean something, since an allocation becomes a priority the scheduler honors rather than a row in a table. Compounds with T. Cons: The largest item in the section. Scheduling is a hard problem, and a naive greedy implementation produces schedules that look fine and waste good nights. Also a UX problem: a user who cannot see why their observation was not scheduled will assume it is broken.
Context: LCO open-sourced their work here (rise_set, adaptive_scheduler,
observation-portal) and it is worth reading before writing anything. The
existing request-group state machine in
server/src/routes/proposals.js and
services/lifecycle.js is roughly the right shape for what a scheduler
consumes.
Progress (2026-09-12): The engine exists. services/observability.js does the geometry: sidereal time, precession, alt/az, Kasten-Young airmass, Sun and Moon positions, twilight bands, visibility windows and per-target constraint evaluation with a stated reason for every refusal. Verified against astropy at three sites and four epochs, which is how the J2000-versus-of-date frame bug was caught: it put every altitude 0.37 degrees out, always in the same direction, and nothing but an independent ephemeris would have found it.
services/dispatch.js replicates the ACP Scheduler design from Denny, Dispatch Scheduling of Automated Telescopes, Proc. Society for Astronomical Sciences 23, p.35 (2004), which adapts Steele & Carter (Proc. SPIE 3112, p.222, 1997). Replicated rather than invented because ACP is what small observatories have run for twenty years and DC-3 Dreams no longer supports it: an operator moving across should meet the same behaviour. That means the six-term efficiency function with its published coefficients (priority 1.0, transit 0.8, slew 0.7), per-user priority normalisation to a mean of 0.5, the Lorentzian moon-avoidance distance, the four-value sky quality scale, and the rule that a running plan is never abandoned for a better unstarted one.
Not yet done: linked observations (a plan of several targets with timing tolerances, which is what asteroid follow-up and variable-star work need), the forward time projection that checks a whole plan can complete before it starts, the "rising plan delay" refinement from later ACPS versions, and any UI.
V. Executable methods
What: Make a published observation reproducible as an artifact: the exact Nox program, the exact calibration masters, the exact solver and index set, and the software versions, bundled so a reader can re-run it.
Why: Unique to Caelum and probably underrated. Nox is a typed language with units and coordinate frames as first-class types and structured rollback, which means an observation script is already a precise, checkable description of a method rather than prose. Combine it with the provenance model and a data release and a paper's methods section becomes runnable. Reproducibility is a live sore point in observational astronomy and nobody else is positioned to offer this.
Pros: Differentiating in a way no feature list can copy quickly, because it depends on having a typed DSL and a provenance model already. Most of the ingredients exist. Cons: "Re-runnable" is a strong claim and needs pinned container digests and archived index files to be true, not just recorded version strings. Easy to ship something that records provenance without actually being reproducible, which is worse than not claiming it.
Blocked by: L, S.
W. Machine-readable object and release pages
What: Server-render, or expose a static metadata surface for, the object dossier and data release pages. Structured metadata for each.
Why: Caelum is a client-rendered SPA, so a crawler or an AI assistant fetching an object page sees essentially nothing. For a platform whose value depends on being discovered and cited, that is a real problem and it is invisible from inside a browser, because the page looks fine to a human.
Pros: Affects adoption more than most features in this section, and it is bounded: two page types, not the whole app. Cons: Introduces a rendering path the SPA does not currently have, which is a build and deploy change rather than a feature. A static metadata surface is cheaper but duplicates truth, so it needs to be generated rather than maintained.
Context: Same failure mode as the Hitt Hosting flagship, where llms.txt
and a noscript block are the only machine-readable surfaces. The object
dossier at client/src/views/ObjectDossier.vue
is the page most worth citing and the one most worth rendering.
Not worth building
Recorded so the question does not get re-litigated.
Our own photometry or astrometry numerics. astropy, photutils, SEP, ccdproc, astroalign and astroquery are validated and trusted. A bug in our own aperture sum produces plausible wrong answers. Decided as part of L.
Our own alert broker. ALeRCE, Fink, Lasair and ANTARES exist and are maintained by people whose job it is. Consume them.
Our own catalog crossmatch service. CDS X-Match and VizieR already do this at a scale and quality we will not reach.
Spectroscopy, for now. instruments.type already accepts spectrograph and
nothing handles it. Wavelength and flux calibration, plus 1D extraction, is a
section of its own and it should not start before photometry is solid.