Files
Paul HittandClaude Opus 5 71febaf14f feat(scheduler): observability engine and an ACP-compatible dispatcher
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>
2026-09-12 20:16:06 -04:00

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.js uses MySQL-specific syntax (ENGINE=InnoDB, AUTO_INCREMENT, utf8mb4, backtick-quoted reserved words) that needs a parallel SQLite DDL or a transpiler
  • addColumnIfMissing queries INFORMATION_SCHEMA - needs SQLite's PRAGMA table_info equivalent
  • mysql2 typeCast 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.

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 a reduction-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) and extract.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 timing job against a live API, computes BJD_TDB, reports it, and the run settles complete with the software versions recorded. docker compose --profile reduction up -d.
  • Phase 3 is half done. extract shipped ahead of astrometry because 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 from astrometry to calibrate: 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_sources holds 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.