v0.9.7

• Kayra: the sidebar header shows the logo with a short "Kayra by Skyulf"; the separate
  "by Skyulf" line at the bottom is gone. The loading screen plays the new logo animation
  (the still logo when reduced motion is on), and the rebuilt app shows the updated logo
  as the browser icon and in the sidebar.
• Documentation is built with Zensical instead of MkDocs; page addresses are unchanged.
  The menu is organized by product: Home, Kayra App, skyulf-core, "Databricks, MLflow &
  Spark", API Reference and Development. Pages have a site description for search
  engines, and the Segmentation guide is now in the menu.
• Generated Databricks projects pin skyulf-core[mlflow]==0.9.7.
• Serving: when an endpoint update fails (UPDATE_FAILED / UPDATE_CANCELED), the
  error now includes each served entity's deployment message and the last 50 lines
  of its build and server logs. Only the endpoint owner (the job identity) and admins
  can open these logs, so the job prints them. The serving_endpoint job and the
  daily rollout both do this; a problem reading the logs never hides the original
  error.
• Serving: config/serving.yml permissions accepts level: CAN_VIEW entries. They
  get endpoint CAN_VIEW right after the endpoint is created or updated, before the
  readiness wait, so a team can see a deployment that fails. CAN_QUERY and SQL
  EXECUTE are still granted only after the endpoint is verified; viewers never get
  EXECUTE. Listing one principal at both levels is rejected.
• Failed job tasks print a Fix: and Docs: line for known errors: a failed serving
  update, an owned endpoint without exactly one served entity, a champion from an
  older Core release, an invalid on_drift, a performance policy without a label
  table, an uninitialized monitoring store, Streaming Table operations and Unity
  Catalog permission errors. The troubleshooting page has a section for each.
• smoke.py rejects an on_drift value other than disabled or retrain in
  deployment/variables.yml or any target in deployment/targets.yml, before deploy.
• GUIDE.md: a "Failures and upgrades" row for a champion trained on an older Core
  release, and how to install Core from a wheel in a Unity Catalog Volume for every
  job. Regenerate or copy the new rows into existing projects if you want them.
• Training reads a Streaming Table, Materialized View or view directly as
  training_table (and as the label table joined into training rows). No features-job
  copy and no extra Unity Catalog table is needed. Each run reads the source once and
  saves the rows with its MLflow run; registration, comparison, approval, monitoring
  references, retraining checks and model-set components replay those saved rows, for
  Delta sources too, so VACUUM no longer breaks an old model's replay (deleting its
  MLflow run does). On dedicated clusters a refused history read
  (STREAMING_TABLE_OPERATION_NOT_ALLOWED) falls back to a plain read. Models trained
  before this release keep reading their Delta version. feature_lookup still needs a
  Delta training table and says so. preview.py --action sources accepts these sources
  for training.
• Model-set approval works when score_source_table is a materialized view, a view or
  a Streaming Table on dedicated compute: the approval probe reads it plainly instead of
  pinning a Delta version it does not have. Other history errors still fail.
• Endpoint monitoring for a model set joins delayed labels on the set's record keys
  when the label table has no databricks_request_id/request_row_index columns, so a
  table that already holds keys and targets (for example a silver Streaming Table) is
  enough. The latest request per key counts; duplicate_key_rows and
  unkeyed_requests are reported, and drift still uses every request. Label tables may
  be Streaming Tables, materialized views or views (read without a version pin), and the
  availability column may be a DATE (00:00 UTC). A DATE label key matches a
  yyyy-MM-dd request value. Switching a monitor to a record-key table starts a new
  performance streak.
• Single-model endpoints can join delayed labels on the training record keys too. The
  Skyulf SQL function takes the keys as optional arguments (DEFAULT NULL, sent as
  text; the model ignores them), REST callers may add them as extra fields, and
  requests without keys count as unkeyed_requests. The first serving run after the
  upgrade replaces an existing single-model SQL function once.
• serving_endpoint no longer fails when the label table does not exist yet: it
  enrolls with a warning, performance reports awaiting_labels and drift runs. Rollout
  holds instead of failing.
• baseline.model_version is optional for kind: training_holdout (default: the
  enrolled version); generated policies leave it out.
• When initialize_run fails, the training report no longer adds a second, misleading
  failure (Failed to resolve references: ... tasks.initialize_run.values.tracking_uri).
  The report reads the run reference at run time and says that initialize_run did not
  finish, so its own error is the one to read. Redeploy to get the new job definition;
  jobs deployed earlier keep working.
• Clean break: monitoring rebuilds each model's drift and retraining reference from the
  training rows saved in its MLflow run (checked by SHA-256). No monitor_ref_* or
  monitor_src_* tables are created or read any more, so the scheduled
  monitoring_cleanup job, its variables and the cleanup_references action are
  removed. Models trained before 0.9.7 stop with a message to retrain; regenerate older
  projects and drop their old reference tables once with the SQL in the monitoring
  setup guide. A monitoring job that runs as another identity needs read access to the
  training experiment.
• Personal *_development targets get a cleanup_dev job (shared targets never do). Run it
  with dry_run=true, review the list, then dry_run=false, then bundle destroy. It
  removes only what that deployment created: the owner-tagged serving endpoint and SQL
  function, this deployment's monitoring rows in the development store, its registered
  models, prediction tables, views and generations, and the endpoint payload logs. Names
  come from the project's own configuration and must carry the target's suffix; source,
  label and training tables are never touched. A rerun finishes a partial run.
• GUIDE.md has a "Permissions and identities" section listing every place access is
  set (target permissions, run_as, job ACL variables, Unity Catalog grants, the MLflow
  experiment, serving permissions and function_permissions). It warns that the
  experiment now holds training rows, so its read access should match the source tables.
• New projects start with max_rows: 1000000 and max_input_mb: 512 (were 10000 and 64;
  quick setup never asked, so any table above 10,000 rows stopped training). GUIDE.md
  explains that max_input_mb is pandas memory, not file size, and to keep it near
  1/8-1/10 of the driver memory. Existing projects keep their values.
• Endpoint monitoring works on endpoints created by current Databricks: their payload view
  reads request_date and request_time from the log table's date and time columns
  instead of attributes, which the view check used to reject ("Serving view does not
  match the canonical telemetry projection/filter"). Both view shapes are accepted, and
  the logs are read with the projection the view actually uses.
• The GitHub repository is now flyingriverhorse/Kayra and the site with its manual moves to
  kayra.skyulf.com (www.skyulf.com becomes the Skyulf company site). Links in the
  READMEs, package metadata, docs, issue templates, generated Databricks projects and the
  documentation links printed by jobs point to the new addresses; CNAME, the sitemap and
  robots.txt follow. Regenerate a Databricks project to pick up the new links.
• New landing page for Kayra at kayra.skyulf.com: a Skyulf product bar (Kayra, Koloni)
  above a sticky Kayra header, a 30-second app tour video, the leakage check shown with the
  library's real warning and the canvas run block, an evidence section that links each
  claim to its code, notebook or demo, and SEO metadata for the new address. All app
  screenshots were retaken with the current Kayra interface; 20 unused images were removed.
• The manual has 15 new draw.io diagrams, each an editable .drawio source beside its SVG:
  a system overview and the training-job lifecycle (Architecture), the app map, how the
  canvas runs pipelines, multi-path jobs and the exported model project (Kayra App), the
  SkyulfPipeline life cycle, tuning, automated EDA, serialization and drift decisions
  (skyulf-core), and the bundle jobs, model lifecycle, monitoring loop and serving rollout
  (Databricks). The project export quickstart shows current screenshots.
• Access groups per environment: each shared target in deployment/targets.yml sets
  access_viewers (CAN_VIEW on jobs, dashboard, project folder/experiment and the endpoint),
  access_runners (CAN_RUN), access_serving_callers (endpoint CAN_QUERY and SQL function
  EXECUTE when config/serving.yml lists no permissions) and access_data_readers (SELECT
  on prediction tables and views, granted after every score; a refused grant fails the task
  and names the group). Setup asks for them after one opt-in question; quick setup leaves
  them blank. Replaces the test/syst/prod_view_group answers. Endpoint callers also get
  CAN_VIEW right after the endpoint is first created.
• Clean break for generated Databricks projects: only job-graph contract 3 is accepted;
  older graphs stop with "regenerate the project with Skyulf 0.9.7 and redeploy the
  Bundle". Every training run saves the rows it reads, and registration, comparison,
  approval and monitoring (pandas and Spark) replay only those rows; a model without...

v0.9.6

• Security: generated projects pin mlflow==3.17.2 (was 3.16.1; GHSA-wqmh-qccw-pqwf,
  GHSA-2wqp-q3c6-ccj5). The lock file also moves pillow, certifi, filelock,
  gitpython, nbconvert and virtualenv to patched releases. Existing projects can
  raise their own mlflow pin; already trained models keep their saved requirements.
• GUIDE.md is easier to start from: a "How do I" table, short definitions of the
  terms it uses, plain bullets for source keys, and copyable YAML for a preprocessing
  recipe, a pre-split filter, a fixed model with a quality threshold, scoring
  eligibility rules and turning on monitoring.
  It also shows a custom Python step end to end, how to add serving to a batch
  project, where the feature-table example lives, monitoring setup as ordered steps,
  scoring behaviour as plain bullets and a "what failed / what to do" table.
  Gaps found by two fresh readers (Sonnet and Haiku, guides only) are closed: which
  recipe runs by default, what to do after changing each file, which metric the
  quality threshold uses, that derived columns reach the model, inclusive scoring
  bounds, mode: combined, the project init command, the warehouse ID and the
  monitoring store when setup had monitoring off.
• Generated Databricks projects now ship two guides instead of 14: README.md for
  the first run (former START_HERE.md, plus a short learning exercise) and
  GUIDE.md for settings and operations (former SOURCES.md, TRAINING.md,
  PREPROCESSING*.md, SCORING.md, SERVING.md, FEATURE_TABLES.md and the
  deployment/, src/features/, src/monitoring/ and src/tools/ READMEs).
  Existing projects keep their files; when upgrading, the old guides can be
  replaced by the two new ones. Config comments point to GUIDE.md sections.
• Databricks template: define every Bundle target in deployment/targets.yml
  only, so CI rules that allow targets: in one file pass. Per-target monitoring,
  development monitoring and dashboard create/connect settings moved there from
  the removed deployment/monitoring.yml. refresh_feature_graph no longer writes
  targets: into resources/features.job.yml; it prints the feature job's
  per-target run_as/permissions, and smoke fails until they are merged (or until
  leftover entries are removed after feature groups are turned off).
• Personal development targets keep the project in job names
  ([dev <user>] <project>_train) instead of short dev_<user>_train names that
  collided across projects deployed by one identity.
• Jobs no longer render an empty health block, which failed bundle deploy with
  the Terraform engine. The *_health_rules variables are removed; add duration
  warnings as health.rules on a job under a target in targets.yml.
• Policy-cluster projects define the job cluster once, in the complex job_cluster
  variable used by the train, score, serving and feature jobs. Add fields a cluster
  policy requires (data_security_mode, runtime_engine, use_ml_runtime, ...)
  there instead of editing each job file.
• Init answer files accept output_schema and metadata_schema next to schema
  (now the input schema), so test variables, preview.py and smoke.py resolve
  outputs and models in the right schema. Blank values keep using schema. The
  project setup guide shows how to run bundle init without valid credentials.
• New init-file answer include_examples (default true). false generates the
  project without example recipes, example callback files and feature-group
  examples, so they no longer have to be deleted by hand.
• First run for a single model with batch scoring: START_HERE.md no longer sends a
  pinned project through approval. Step 5 scores the registered version for one run
  (--params score_model_version=N); approval is an optional later step for champion
  scoring; with score_follow_champion it notes that approval starts a score run.
  Monitoring steps appear only when monitoring is on. The monitoring
  question now comes before the outcome-table questions, which a single_table
  project without monitoring no longer asks (quick setup: 12 questions instead of 14).
• Spark drift for 1,000-10,000 rows per side now uses SciPy's exact two-sample KS
  count, the same one local ks_2samp uses. The conservative DKW bound used before
  could never reject without drift, so healthy data showed every feature's
  statistical evidence as unavailable and the model as degraded. The bound
  remains the fallback if SciPy's helper is unavailable.
• README's learning exercise is concrete: pin training_table_version to the first
  report's Delta version, change one setting (before/after n_trials YAML), retrain,
  then compare both reports and score the new version for one run. A
  "Unity Catalog grants" row links the required access table.
• Registered model versions now appear in the experiment's Models tab: after
  registration, Skyulf adds a metadata-only MLflow 3 LoggedModel linked to the fitting
  run, tagged with the registered name, version and run URI and carrying the run's
  metrics. The run artifact stays the only model copy and the registry source; a
  backend without LoggedModels logs a warning and registration continues.
• Single entry point: with the new features_start_training: "true" Bundle variable,
  the features job starts the train job after merge_features, so one scheduled job
  runs features, training and the training's score handoff (and scoring's monitoring).
  Default "false"; run refresh_feature_graph.py to add the tasks to an existing job.
• GUIDE.md names the upgrade-safe places to customize a project (src/features/,
  deployment/, the SKYULF_MODEL_PIP_* packaging variables) and says not to
  edit src/jobs/*.py, which a template upgrade replaces.
• config/features.yml table names accept the training.yml placeholders
  ({catalog}, {input_schema}, {output_schema}, {metadata_schema},
  {resource_suffix}). The feature job receives each target's values, so one file
  serves every target and personal outputs no longer collide. Existing feature
  projects run refresh_feature_graph.py and redeploy before using placeholders;
  the refresh now writes LF line endings on every OS.
• Serving projects: the README's serving steps name the version for one run
  (serving_endpoint --params model_version=N), show where the run output proves
  what is live (model_uri, REST/SQL verification) and where the call examples are;
  the preview summary adds the same serving line for endpoint and both delivery.
• src/tools/preview.py starts with a short summary for a single model or competition:
  training settings, holdout, activation (including a missing quality_threshold),
  the scored version, and what it did not check (Core: preview_summary).
• Serving: an owned endpoint whose first deployment failed (no served entity) is
  repaired on the next run instead of failing with "exactly one served entity",
  so it no longer has to be deleted by hand.
• Serving: new optional function_permissions in config/serving.yml lists the
  Unity Catalog grantees for the SQL function's EXECUTE separately from the
  endpoint's CAN_QUERY callers. Unity Catalog rejects workspace-local groups
  such as users. Omitted, both grants keep using permissions.
• SHAP: when the encoded feature width exceeds max_features, the explanation
  result now records feature_count and max_features, and preview.py warns
  when the recipe contains a column-expanding step such as OneHotEncoder.
• config/training.yml: allow_tested_custom_steps is renamed
  probe_pipeline_for_serving, because it checks the whole pipeline for Spark and
  endpoint serving, not only custom steps. The old name is still accepted; setting
  both fails.
• MLflow: experiments are created with mlflow.experimentKind=custom_model_development
  (added to an existing experiment that has no kind), so Databricks lists them
  under "Machine learning".
• Serving SQL function: a NULL in an integer or boolean input that had no missing
  values in training now raises an error naming the column. ai_query used to
  send it as 0/false, which bypassed the fitted imputers. Existing functions
  with such inputs are replaced once on the next serving run.
• Model packages: new opt-in environment variables SKYULF_MODEL_PIP_INDEX_URL,
  SKYULF_MODEL_PIP_EXTRA_INDEX_URLS and SKYULF_MODEL_PIP_BUNDLE_WHEELS let
  Model Serving install from a private index, or from dependency wheels saved in
  the model with --no-index, when public PyPI is blocked. Unset, logged models
  are unchanged.
• Record keys: DATE/TIMESTAMP key errors now name the column and say how to store
  it (yyyy-MM-dd STRING or yyyyMMdd BIGINT). The features guide documents the
  ready-training-table route with a natural composite key.
• Training: without training_sample_rows, rows removed by
  filter_unavailable_results (and, in multi_target, rows whose branch target is
  missing) are now dropped on Spark before the max_rows limit, so full-snapshot
  sources with many unlabeled rows no longer fail. Saved evidence is unchanged; existing models
  replay as before.
• Casting to string writes integral floats without .0 in newly fitted models
  ("81", not "81.0"), so nullable integer codes match fixed one-hot
  categories. Saved models keep their text. OneHotEncoder warns when a column
  matches none of its fixed categories.
• Features: optional base_transform: src/features/<module>.py:<function> in
  config/features.yml runs on the pinned base before group joins, so the target
  and record keys can be derived from a raw table without a separate job. It works
  with no groups; the job then has only initialize and merge tasks.
• config/training.yml: new skip_missing_targets skips rows whose target is
  empty instead of failing (they do not count toward max_rows). New single-model
  and co...

v0.9.5

• Require aiohttp 3.14.4 or later and refresh the dependency lock to include
  fixes for resource exhaustion, initial request timeouts and secure cookies.
• Export a completed Kayra Model Registry version as a standalone FastAPI,
  CSV/Parquet batch, or combined project. Preserve fitted preprocessing and enabled
  saved thresholds, include dependency pins and raw input schema, and reject
  unsupported contextual/custom artifacts. New linear training runs record the
  raw schema without changing model fitting; older artifacts need retraining or
  notebook export. Exporting does not change the active deployment.
• Restore Normalizer and QuantileTransformer outputs as numeric arrays before
  reconstructing columns, including when serving enables sklearn's pandas output.
  This fixes prediction failures in Kayra serving and exported projects.
• Include the current Core wheel in exported projects, expose typed API inputs
  and available classifier probabilities, and process batch files in bounded
  chunks with atomic output replacement. Keep missing values and identifier
  precision during schema conversion.
• Ignore canvas display labels and inactive imputer constants during fitted
  capability checks, so ordinary canvas pipelines remain exportable. Show the
  backend's actual export error message in the Registry.
• Export pipelines with built-in outlier filters (IQR, Z-Score, Elliptic
  Envelope, Isolation Forest, Local Outlier Factor, Manual Bounds) and Box-Cox
  Power Transformers. Like Databricks saved scoring, a rejected row keeps its
  position with a null prediction, scoring_status excluded and an
  exclusion_reason naming the filter. Refuse project-code function steps
  whose module is not packaged. Add a project export quickstart with flow
  diagrams, render Mermaid diagrams in the documentation site, and link the
  feature from the landing page.
• Convert fold preprocessing outputs to numeric model inputs before LightGBM
  fitting and scoring across grid, random, halving and Optuna tuning. Preserve
  fold-specific preprocessing, row alignment and temporal validation.
• Key serving permissions by Bundle target when groups differ per workspace:
  each target grants only its own principals, an unlisted target grants
  nothing, and the smoke check rejects unknown target names. The flat list still
  applies to every target.
• Validate serving SQL samples against the saved model dtypes before changing
  endpoints. Preserve nullable integer/boolean values and reject nulls in a
  nonnullable boolean contract. Check configured serving outcome tables for
  request IDs and row indices before deployment.
• Compare serving and lifecycle model names during initialization. Deduplicate
  automatic serving submissions by promotion event across daily runs, while
  retaining parent-run deduplication for older generated projects.
• Allow owned endpoint updates to retry terminal failed/canceled updates after
  checking both current and pending configuration. Active updates, foreign
  models, conflicting logging and unsupported runtime settings still block writes.
• Read older rollout plans without weakening saved-digest validation. Accept
  null exclusion explanations on successfully predicted smoke rows. Recover
  definitely unsent rollout requests; uncertain or legacy prepared requests
  remain reconciliation-only. Release an untouched alias intent when its
  pre-write guard refuses the operation.
• Preserve DECIMAL duplicate identities through pre-split filtering, then
  normalize model-input overlaps after survivor and split membership are fixed.
  Retain conversion evidence through saved holdouts and fitted model packaging.
• Compact repeated DECIMAL conversion metadata when needed to fit the existing
  bounded manifest. Existing artifacts remain readable; newly compacted
  manifests require this updated loader. Long MLflow feature-list tags now use
  count, digest and artifact references instead of exceeding the tag limit.
• Allow feature-table maintenance version changes only after exact retained
  snapshot schema and row-content verification. Use frozen feature lookup
  bindings during retraining and model-set composition probes.
• Preserve large integer model-set keys when predictions are excluded and widen
  native small integer keys losslessly for Spark publication. Bound functional
  approval samples for certified row-local sets; context-dependent sets retain
  their full-population limits.
• Fence managed feature publications with a durable generation and initialized
  snapshot. Superseded repairs cannot overwrite newer groups or merged output;
  deterministic retries of the same snapshot remain supported. Existing
  in-flight snapshots without publication metadata must be reinitialized.
• Improve Bundle setup validation for removed answer names, reserved cost tags
  and endpoint settings. Endpoint-only source checks no longer require batch
  CDF, and preview selects an appropriate default action. Generated long
  endpoint names use a deterministic shortened form; explicit invalid names
  remain errors.
• Make personal development targets complete working environments: endpoint
  projects follow the champion there too, with per-user endpoint and SQL function
  names. The optional development_monitoring answer measures development models in
  their own store, named in setup (development_monitoring by default; any name
  except the shared monitoring schema) and, with monitoring_dashboard: create,
  gives test_development its own dashboard. Every job receives both schema names
  and Core refuses a development store that is missing or equals the shared one.
  Development never retrains.
• Simplify monitoring setup. Setup asks monitoring (on/off) instead of a
  catalog: monitoring_catalog defaults to each target's own catalog, and the
  schema names stay in deployment/variables.yml. The new
  deployment/monitoring.yml holds each target's monitoring in one place: the
  per-target dashboards (create or connect, with commented examples and how to
  find the warehouse ID) and the development targets' monitoring settings, which
  leave deployment/targets.yml. The monitoring_dashboard answer fills the
  test target; syst and prod are set by hand. This replaces
  src/tools/configure_monitoring_dashboard.py and its two generated files.
• Keep the monitoring job template readable as YAML before rendering; rendered
  jobs are unchanged.
• Preserve missing floating inputs in serving monitoring when ai_query logs
  them as NaN. Only declared float input columns accept this missing-value
  representation; infinities, nested values and nonfinite predictions still fail.
• Allow endpoint-only training with monitoring enabled without requiring a batch
  prediction table. Validate active serving settings before training or champion
  changes, while preserving development and manual-serving behavior.
• Preserve observed Spark source conversions during lifecycle validation and
  competition winner adoption, including sources with no DECIMAL columns.
  Saved configuration checks still reject inconsistent conversion evidence.
• Preserve Spark conversion metadata when saving and reusing feature-enriched
  holdouts. Receipts use the same JSON representation as Parquet, so tuple/list
  serialization does not block comparison or approval; altered evidence still fails.
• Configure gradual serving traffic in serving.yml with traffic_step_percent,
  stage_minimum_hours and evidence_max_age_hours. Defaults remain 10 points
  and 24 hours. Initialization reads the same settings; jobs reject policy
  changes on an existing rollout. Short stages support isolated testing without
  bypassing request, label, health or final-promotion checks.
• Evaluate live rollout labels by Databricks request ID and row index without
  requiring training record keys among model inputs. Exact endpoint, model,
  output schema and label coverage checks remain enforced.
• Add the prepared taxi_fare_endpoint example: automatic champion-following
  REST/SQL serving, telemetry monitoring and a dashboard walkthrough, using
  sample NYC taxi data without a batch score job or prediction table.
• Clarify Bundle configuration names: include_online_feature_lookup, the
  online_feature_lookup section and online_feature_lookup_setup job describe
  the separate feature lookup setup. Training uses training_table_version
  and training_label_table_version to identify Delta snapshots. Serving checks
  use verification.sample_rows and return comparison counts under
  verification; remove the redundant serving_endpoint.selection field.
  Previous public names are rejected; Python SDK names, legacy workflow JSON
  and saved training evidence retain their existing names. Regenerate projects
  or update their YAML, job resource names and notebook paths together.
• Retrain model sets after a Core runtime upgrade while retaining the pinned
  incompatible champion. Explicit allow_unloadable_champion approval rechecks
  saved quality gates and the expected champion, records consent, and drives
  the existing score/serving handoffs. Rollback requires a compatible runtime.
• Choose prediction_delivery: batch, endpoint or both in detailed Bundle
  setup. Endpoint-only projects retain training and monitoring while omitting
  the batch job, its handoff and prediction destination. Quick setup stays batch.
• Control automatic serving updates with follow_champion: true in config/serving.yml without regenerating its
  dispatch graph. Production mode, concrete version receipts and non-blocking
  submission remain required. Inactive automatic handoffs skip endpoint binding
  validation, so personal targets and manual-only serving do not block training.
• Automatically enroll logged endpoint versions after successful verification,
  including each model-set branch. Repeated runs preserve identity; replacing a
  version disab...

v0.9.4

• Configure scoring eligibility, prediction bands and combined model outputs in
  config/scoring.yml, with saved custom Python helpers where needed. New Bundle
  projects use YAML; existing Python-only policies keep their behavior.

• Warn about the new learned preprocessing steps before a train/test split even
  while the Canvas registry request is pending or unavailable.

• Reject invalid serving-monitor enrollment batches before acquiring the shared
  reference lock, so configuration errors cannot write a lock record or be
  hidden by an unavailable monitoring store. Valid enrollments remain guarded.

• Add FrequencyEncoder, RareCategoryGrouping, QuantileTransformer, Normalizer,
  IsolationForest and LocalOutlierFactor with saved-state checks, Canvas controls
  and weighted-pipeline row alignment. Joint outlier inference preserves request
  rows with exclusion reasons; LOF distinguishes training from novelty scoring.

• Add fit-time regex/dtype/exclusion column selection, hierarchical multi-column
  GroupImputer fallback, learned group deviations, cyclic/local-time date
  features, independent Count/TF-IDF vocabularies per column, per-column
  Winsorize percentiles, RFECV and sequential feature selection. Expose target
  encoder CV/shuffle/seed, MinMax clipping and Robust unit-variance options.

• Reject misspelled preprocessing choices, malformed ordinal orders and invalid
  hash widths instead of silently using fallbacks. Standardize new HashEncoder
  defaults on eight buckets, exclude targets from automatic polynomial expansion,
  and normalize missing TargetEncoder category identities for new fits.

• Validate simple-transform rule containers before reading their entries, so
  malformed rules fail clearly and rejected iterators remain unconsumed.

• Keep floating sentinel-to-null replacements numeric. Interpret constant
  imputation text in each selected column's numeric/Boolean type with explicit
  errors for invalid or lossy values. Improve schema previews without guessing
  engine- or data-dependent output types.

• Version new FeatureMath operation validation and nullable calendar outputs;
  previously saved unversioned operations retain their replay behavior. Keep
  existing arithmetic null/zero rules and exact integer clipping boundaries.

• Document tested built-in alternatives beside custom Bundle teaching examples,
  including differences in missing values, output names and dtype handling.

• Add explicit ordered string categories and optional column_names: slug to
  OneHotEncoder, including Canvas controls. Fixed vocabularies produce stable
  columns even when a training split lacks a category; legacy saved encoders
  retain their original names and behavior.

• Compute context-dependent SHAP preprocessing before sampling explanation rows,
  preserving lag/rolling history and exclusion counts. Row-independent pipelines
  retain early sampling and the same SHAP budgets.

• Raise an explicit error when a saved GeneralTransformation power transform
  cannot apply, instead of silently substituting raw values for the whole column.
  Previously saved pipelines that relied on that fallback now fail explicitly.

• Return an unknown preview schema for GroupImputer automatic numeric selection,
  whose selected columns depend on observed binary/constant values; explicit
  column selection is unchanged.

• Raise the SHAP explainability.max_features guard from 50 to 100 so wider
  models, such as fixed one-hot feature sets, can be explained.

• Add optional initial_scoring: from_now: the first batch records a Delta
  checkpoint without predictions, subsequent batches score new inserts, and
  model changes/recovery preserve the original boundary. full_snapshot
  remains the default. Normal rebuilds reuse saved prediction keys and recent
  CDF; CDF-expiry recovery requires the original starting snapshot.

• Generate config/sources.sql only when setup selects include_source_sql;
  the source guide and read-only source checks remain available in every project.

• Keep outcome availability columns on the outcome table in the optional
  config/sources.sql starter for separate_outcomes, so measurement tables
  do not require label metadata for single-model, competition or model-set training.

• Generate source layouts, outcome-table bindings and task-aware performance
  policies from setup answers. Quick setup includes table arrangement; generated
  SOURCES.md, SQL starters and preview.py --action sources explain and check
  existing source contracts without creating source tables.

• Train from an optional separate outcome table using exact record keys and
  pinned Delta versions/identities. Newly available labels can enter guarded
  retraining even when feature rows have not changed. Saved runs retain the
  original outcome binding; embedded-target configurations keep their identity.

• Expose sampling and preprocessing diagnostics in detailed setup, explain row
  and byte limit failures, and warn about initial in-sample scoring and scheduled
  fixed training windows. Monitoring jobs accept native email/webhook and
  duration-warning settings; drift alerts remain separate SQL alerts.

• Default configured monitoring to the shared skyulf_monitoring schema while
  preserving custom destinations. Generated projects add a separate weekly
  reference cleanup job with confirmation enabled and 90-day retention; personal
  development targets remain paused. Manual cleanup defaults to a dry run.

• Serialize reference publication, enrollment and generated model activations
  with cleanup through the existing Serializable request table. Failed protected
  writes retain their owner; validation failures before a write release it.
  Known contention waits within a bounded deadline. Explicit recovery verifies
  job identity/termination and audits the release. All writers sharing a store
  must participate or be paused.

• Write format-2 monitoring references as one population with training membership
  plus a receipt; share source tables only when verified content and schema match.
  Legacy references remain readable, and existing tables are not migrated.

• Monitoring can treat per-column missing-value markers, such as a -200
  sensor reading, as missing: add missing_markers to
  monitoring_drift_thresholds. Markers compare exactly in the column's own
  integer or floating-point type. Reports without the key are unchanged.

• Add a single-table air-quality walkthrough: train on summer observations,
  append winter days with separate outcomes, and score new rows with Spark.
  Serial loader retries recover missing inputs or labels without duplicate
  inserts. Use a shared monitoring schema for the air-quality examples and
  clarify that daily performance windows follow prediction time, while
  report mode records the first eligible loss without waiting for a streak.

• Pin sqlalchemy==2.0.43 in generated deployment/requirements.txt. MLflow
  3.16.1 allows any sqlalchemy<3, and 2.1.5 has no wheel for the serverless
  aarch64 image, so its source build failed and stopped every job at library
  installation.

• Add the prepared real-data air_quality_no2 example on UCI Air Quality:
  built-in and custom pre-split filters, custom marker/category/fitted steps
  with built-in IQR exclusion, Yeo-Johnson, imputation, one-hot and scaling,
  combined scoring rules, Spark UDF scoring, SHAP, evaluation charts and
  monitoring on a later season with a report-only WAPE policy. The real-data
  loader gains the pinned archive and a datasets widget for selective loading.

• Add unweighted WAPE alongside existing regression metrics, with an explicit
  unavailable outcome for all-zero actual values. Support heldout_wape in
  model comparison/quality gates and wape in performance policies; show its
  label, explanation and lower-is-better direction in Kayra.

• Configure categorical grouping, uniqueness, summary caps, PSI severity bands
  and non-Spark monitoring row/byte budgets through the existing
  monitoring_drift_thresholds JSON variable. Preserve absent-key defaults and
  reject invalid values before measurement; Spark and frame engines share validation.

• Measure repeated categorical drift above 50 reference values in pandas/Polars
  and Spark using the top 50 reference categories plus a pooled tail. Bound
  domains at 10,000 categories and skip reference uniqueness above 0.5. Preserve
  existing small-domain results and add a diagnostic new-category rate on the
  grouped path; statistical support is still required for drift alerts.

• Prefer build_model_rules() in project feature packages while retaining
  build_scoring() for older projects. Generated projects no longer need an
  alias. Correct automatic admission of reused pre-split rules and explain
  row-only replay, exclusions and admission settings in the template.

• Add the prepared taxi_fare_robust example: fixed eligibility, fitted IQR,
  Yeo-Johnson, imputation, encoding and scaling, with Spark UDF scoring and an
  explicit raw-input endpoint for REST and typed SQL ai_query requests.

• Explain sampled rows accepted by fitted exclusion steps with SHAP, reporting
  sampled, accepted and excluded counts and reasons in JSON and HTML. Fewer
  than two accepted rows remains unavailable; samples are not topped up.

• Generate evaluation charts for models with excluded predictions. Preserve
  the saved holdout sample, plot only its predicted rows, and disclose sample
  counts in captions and task output. Invalid predicted values still fail.

• Configure new serving endpoints through online_serving.endpoint in
  config/serving.yml: CPU workload type, Small/Medium/Large size, scale to
  zero and a positive readiness timeout. Defaults remain CPU/Small/true,
  with a 3600-second setup wait. Setup returns READY only after the exact
  configuration settles; timeout leaves the endpoint available for inspection.
  Existing endpoints are never overwritten. R...

v0.9.3

• Exclude scikit-learn text vectorizers' process-specific stop-word validation
  cache from semantic fingerprints, while retaining their settings, vocabulary
  and learned weights. Recompute fingerprints for pipelines using these
  vectorizers after upgrading.
• Align generated Databricks Bundle requirements and setup guides with the
  Core release version.
• Preserve original class labels in fold scoring, accept NumPy threshold labels,
  normalize sequence targets for explicit CV policies, and ignore empty tuning
  validation splits. Align nested aggregate metric standard deviations.
• Keep Decimal temporal and causal diagnostics available; exclude nonfinite
  cells from target, rule and time-series statistics. Distinguish durations from
  dates and preserve correlations across numeric scales and missing-row overlaps.
• Separate discrete numeric drift levels when reference quantiles repeat,
  preserving large integer and adjacent floating-point boundaries in PSI/KL.
• Preserve Polars Boolean/Enum inputs during model-set scoring and pandas
  dtypes when RobustScaler centering and scaling are both disabled.
• Name the backend and visual application Kayra, with by Skyulf attribution,
  updated API/notebook titles and download names. Keep skyulf-core package names,
  configuration keys and saved-artifact formats unchanged.
• Use the new application logo and transparent SVG loading animation, with a
  static image for reduced motion. Keep the export editor out of the application.
• Show every matching model/version/context in monitoring portfolio views, with
  each policy's own metric, baseline and limit. Separate chart scales and
  confusion counts; retain disabled, unmeasured and unresolved-version failures.
• Keep inference and demo acceptance guards active under optimized Python, and
  validate raw-serving SQL version inputs before accessing Databricks resources.
• Add opt-in continuous Delta-to-online feature publication with native pipeline
  start, status, stop and restart controls. Keep hourly paused jobs for the
  default triggered mode; continuous jobs have no cron. Report first-sync
  evidence separately from pipeline health and per-request feature freshness.
• Add an independent online-serving Bundle selection that carries lookup and
  freshness settings through training and registration. Provide an explicit
  endpoint setup job that checks existing publication bindings and first-sync
  evidence, including externally managed publication and renamed request keys.
• Check complete Python module paths when building Bundle wheels so unrelated
  packages can contain identically named modules without masking stale layouts.
• Add opt-in daily serving traffic increases with durable pending-write recovery,
  stage-specific health and label checks, verified rollback, and guarded automatic
  pipeline champion promotion after the final passing 100% stage.
• Add native online feature publication and saved missing/stale feature guards,
  inspected online request schemas, and optional paused Bundle jobs. Preserve
  existing serving certificates and historical feature snapshot checks.
• Replace the old training, fitted-pipeline, scoring and MLflow import paths and
  names with direct purpose-based APIs; remove the forwarding modules. Rebuild
  saved model packages that reference removed class or module names before
  upgrading their consumers. Artifact-format values remain unchanged.
• Replace SDK runtime="local" with runtime="standalone"; the old runtime
  value is rejected. runtime="databricks" still selects Databricks integration,
  and engine="pandas" or "polars" independently selects the DataFrame engine.
• Rewrite integration guides around execution choices, generated YAML settings,
  preprocessing diagnostics and explicit temporal history; rename the SDK guide
  and update its links while keeping internal validation histories off the
  documentation site.
• Recognize validated explicit empty selections for OneHotEncoder, SimpleImputer
  and MinMaxScaler, and native NumPy integer OneHot category caps. Keep automatic
  empty selections and unusable fitted statistics outside certification.
• Expose local predictions with detached temporal history using the existing
  carry session; share its factory with model-set and Databricks scoring.
• Add an optional saved-preprocessing training check and MLflow report for all
  local training layouts, without changing dataset identity or promotion policy.
• Report saved SimpleImputer and GroupImputer medians as local row operations on
  pandas and Polars, retaining existing worker and portable-codec restrictions.
• Preserve exact GroupImputer integer modes and group keys across native pandas
  and Polars fit/replay. Keep zero-column Polars row counts when restoring missing
  columns, generating bias features and checking saved preprocessing diagnostics.
  Previously rounded fitted group keys or values require refitting affected models.
• Inspect saved local inference state and report row context for ten additional
  preprocessing families, including scalers, feature selectors, missing-data
  steps, fixed bins, value replacement and geographic distance. Preserve exact
  diagnostic failures and keep worker/endpoint admission unchanged.
• Keep univariate feature selection working when a score function such as
  r_regression does not provide p-values; record an empty p-value report.
• Add saved-preprocessing diagnostics using existing apply methods, shared schema
  checks, node-owned state validation and optional custom context declarations.
  Report exact batch/chunk/order parity and state mutation without refitting or
  broadening Spark/REST admission from sample results.
• Define ordered pre-split and preprocessing recipes in separate Bundle YAML
  files. Keep custom functions in the corresponding feature modules and capture
  both declarations and custom source for saved-model replay. Remove redundant
  custom recipe files and reject competing YAML/Python recipe owners.
• Organize Spark table producers under src/features/groups/ alongside model
  recipes. Exclude producers from saved model code while retaining their static
  syntax checks and feature-job source hashes.
• Add optional Spark feature-group jobs with pinned Delta inputs, selective group
  reuse and checked exact/as-of joins into a merged table. Ready-table projects
  retain their existing jobs.
• Generate authoritative training/inference YAML directly for every Bundle
  layout, preserving custom Python transformations and rejecting duplicate
  configuration ownership. Remove the unused project migration tool.
• Extend certified pandas-worker scoring to exact sklearn DecisionTree,
  RandomForest and ExtraTrees estimators, fitted MinMaxScaler, and declarative
  weighted model-set outputs. Local training remains bounded.
• Connect optional Unity Catalog Feature Engineering lookups to bounded training,
  native model packaging and distributed scoring, with frozen feature-table
  evidence, compatible model-set unions and Spark monitoring reconstruction.
  Native workspace acceptance remains pending; online stores are not enabled.
• Check packaged feature/composition assets and dependency declarations in offline
  Bundle smoke checks; report file-specific JSON failures and syntax locations.
• Preserve evaluation reports for valid splits when another split is unsupported,
  while retaining coverage evidence for populations fully excluded by preprocessing.
• Add a generated, layout-specific Bundle first-run guide with editable file
  locations, execution order and stage-based troubleshooting.
• Apply configured job identities and optional permissions to monitoring;
  expose its independent serverless runtime and budget-policy settings.
• Align generated artifact requirements with Core 0.9.2 and reject ambiguous
  wizard prompt ordering before project generation.
• Document the Online serving dashboard page and distinguish saved monitoring
  freshness from source-data freshness and missing telemetry.
• Declare shared monitoring/retraining helpers at their existing owners and
  retain legacy module identities while enforcing internal helper boundaries.
• Split the Core CI suite into four complete file partitions; combine their
  branch coverage with the existing Spark and Delta runtime tests before
  applying the unchanged 90% aggregate coverage gate.

v0.9.2

• Raise the fsspec, Mako and Werkzeug security floors and refresh matching
  locked dependencies for reference-template and Windows path-validation fixes.
• Preserve ordinal bin numbers on Polars 2 by decoding explicit numeric labels,
  including sparse bins, nulls and out-of-range values.
• Keep monitoring and benchmark validation active with optimized Python bytecode.
• Online Databricks monitoring reads actual endpoint telemetry with Spark and
  attributes requests to concrete served model versions. Delayed outcomes use
  request IDs and row ordinals; drift, performance loss and confusion matrices
  share the existing monitoring store, guarded retraining policies and native
  dashboard. Pinned serving helpers validate readiness and named HTTP inputs.
  Upgrade shared inventory readers before enrolling online endpoints.
• Refresh the project landing page, retain keyboard focus inside image previews,
  and publish the machine-readable llms.txt overview with the site.
• Isolate Spark test modules so their names do not collide with integration tests
  during full Core test collection.
• Align application, frontend and standalone Core package versions at 0.9.2;
  source checkouts now report the manifest version in backend settings.

v0.9.1

• Raise security floors for Sentence Transformers, JupyterLab, Notebook,
  Tornado, urllib3, and virtualenv and refresh their locked versions.
  Sentence Transformers now requires 6.x: local models containing custom
  Python modules no longer load through the default untrusted path.

• Databricks scoring supports pre-split reuse, custom rules, or their ordered
  combination, with an independent switch to skip target-dependent steps.
  Templates explain both phases and include missing-value, numeric-range and
  prediction-band examples, commented out by default in both custom rule lists.

• Databricks project models can save exact external dependency pins and bounded
  declared assets, with fresh-process and MLflow replay checks.

• Optional saved scoring policies produce keyed exclusion reasons and typed,
  versioned business outputs; Delta receipts preserve coverage and progress even
  for all-excluded batches. Training/holdout evaluation stays independent.

• Explicit row filters now select the same eligible evaluation population in
  ordinary fits, tuning, CV, and nested threshold selection. Held-out reports
  disclose input, scored, and excluded rows; empty eligible splits report an
  unavailable evaluation. Filtered branch merges without shared row lineage
  fail explicitly. Serving still preserves requested row alignment.

• Distribution drift now requires both a practical effect threshold and
  sample-aware statistical evidence, with Bonferroni correction across valid
  feature tests. Numeric data uses KS; categorical data uses chi-square or
  exact Fisher tests. Tiny samples can report insufficient evidence rather
  than drift or health; there is no universal 100-row rule. Monitoring preserves
  this evidence in reports, and automatic retraining requires current evidence.

• MLflow local pipelines and model sets now transport nullable signed integers
  and Boolean inputs losslessly, restoring their fitted dtypes before feature
  engineering. prepare_pyfunc_input prepares native pandas requests; Spark
  callers cast the declared columns to strings before Arrow conversion. Nulls
  still follow the saved cleaning policy, and integers above 2**53 stay exact.

Added

• Databricks Bundles prepare a version-checked Core wheel during deployment and
  record its SHA-256; content-specific wheel build tags prevent stale serverless package
  reuse after source changes. Shared runtime requirements include selected Optuna and
  optional model/ensemble dependencies plus project preprocessing/scoring pins;
  training-only requirements retain optional SHAP/chart packages. Compute settings,
  worker bounds, job tags and serverless budget policies support target overrides.

• Databricks Bundle classifiers support optional off, manual, and auto
  decision policies, disabled by default in single, competition and multi-target
  model files. Automatic thresholds use a separate training calibration partition;
  CV and competition score the complete policy on independent outer folds.
  Saved models retain binary positive-class decisions and multiclass scaled argmax.
  Split membership and threshold metrics reuse Core helpers.
  Original target labels survive LabelEncoder/OrdinalEncoder, resampling,
  threshold selection, registry reload and holdout evaluation; users do not
  need to supply internal class codes.

• Supported supervised models accept training row weights through Core
  sample_weight and optional weight columns declared in Bundle model files. Weights follow actual
  train/CV/refit rows, can combine with existing classification class_weight,
  and stay outside model features and scoring inputs. Saved training evidence
  records aggregate weights and source/row digests. Row filters, deduplication,
  outlier removal and lag/rolling transforms preserve positional alignment.

• Voting, stacking and calibration support sample weights when every receiving
  base/final estimator supports them. Random sampling transports source weights;
  synthetic sampling uses an explicit class-mean or uniform weight policy.

• Bundle single, competition and multi-target projects expose the same weight
  column setting in their model files, with independent multi-target branches.
  The optional wizard flow filters models using Core's shared capability check;
  no separate weights.py hook is generated. Model parameters remain the place
  to edit class_weight; fixed values are preserved by default search spaces.

• The canvas Class Weight control preserves a real null when switching from
  Balanced to None, including the submitted training configuration.

• GroupImputer preprocessing node fills missing values from each row's own
  group (mean, median or most frequent), learned on training rows only, with an
  overall fallback for groups unseen in training. On the canvas it is the
  Group Imputer method of the Imputation node.

• ClipValues preprocessing node caps values at fixed bounds without dropping
  rows, so the same caps apply at prediction time. On the canvas it is the
  Clip to Fixed Bounds method of the Outlier node.

• Canvas validation flags a missing group_by column, and clip bounds cannot
  reference a target already separated from the features.

Changed

• Personal Databricks development targets skip central model enrollment and
  monitoring, drift and automatic retraining tasks. Shared deployments keep their
  monitoring flow, while development training and scoring handoff remain active.

• Databricks model sets can promote when at least one component meets its
  improvement requirement and no component regresses on its selected metric.
  Equal peers are allowed; all-tied sets remain challengers. Absolute quality
  gates and whole-set activation, approval and rollback checks still apply.

• Databricks Bundles support daily rolling training windows with a selected
  source event column, project-level drift thresholds, and an optional visible
  retrain_on_drift task. Fresh eligible target data, current observations,
  quality checks, durable request deduplication and cooldown guard requests to
  the existing train job; training and approval policies remain unchanged.
  The Job graph shows eligibility and an explicit true/false condition: eligible
  requests recheck the guards before submission; skipped requests show the reason.

• Databricks evaluation images are published in parameter-free Charts child
  runs, preventing long training-parameter headers in native image grids.
  Single, competition and model-set reports link to these children while
  preserving training metadata and reading metric summaries from their source runs.

• Databricks monitoring enrolls models when they become active and runs
  a separate monitor_model task after scoring. Independent model projects share
  a central Delta inventory and AI/BI dashboard; retries preserve active model
  selections and avoid duplicating successful observations.
  New Bundles enable monitoring by default and require a central destination;
  an explicit false setting pauses it. Drift and quality use separate tables
  with per-metric limits. Drift charts show feature PSI against its own limit
  and counts of affected features over time. Performance uses dynamic metric
  columns, explicit true outcome counts, a latest-measurement bar chart and
  a time series for a selected model/version/metric.
  Generated scoring jobs expose a separate drift_report task after monitoring;
  monitoring/report output links to the configured shared dashboard. Drift-count
  charts show full monitoring timestamps and timezone instead of abbreviated hours.
  Multi-target activation and scoring now enroll each pinned component, preserving
  its parent set/version and shared physical output table. Monitoring repairs skip
  only completed component observations; the drift task displays each component.

• Databricks Bundle setup can opt into bounded SHAP explanations with explicit
  training dependencies. Training notebooks and MLflow artifacts show global
  importance and signed sample waterfalls. Competition runs retain the selected
  child's explanation evidence on the parent without recomputing it.

• MLflow training Parameters also show fitted model defaults and selected values,
  ensemble members and internal settings, active holdout controls, and ordered
  preprocessing/pre-split recipe summaries. Complete summaries are saved in
  training_parameters.json; project recipe names travel with the saved pipeline.

• Databricks training runs expose tuning budgets, seeds, strategy settings, search
  spaces and selected model parameters in MLflow Experiments Parameters, including
  competition candidates and multi-target branches. Large values retain a pointer
  to the complete tuning.json artifact; requested and actual trial counts stay
  separate. Nested CV displays the final search's selected parameters.

• Generated Databricks model files use single_model.py, model_competition.py
  and multi_model.py, with plain Python dictionaries for model/search settings.
  Single-model JSON stays empty until the Python declaration is loaded; saved-model
  actions keep using persisted evidence without executing editable training code.
  Legacy file names remain supported, conflicting definitions fail explicitly,
  and the generated wizard schema uses compact formatting with unchanged prompts.

• Databricks Bundle initialization now generates each model's own ensemble params,
  tuning controls and editable Core-derived search space. Multi-target setup creates
  independent branches with target, recipes, CV and quality settings. New projects
  omit shared ensemble.py/tuning.py hooks; existing hooks remain supported.
  Offline preview displays branch settings, and CI checks generated search catalogs.

• Databricks projects can compare named standalone and ensemble candidates for
  one target with shared CV and bounded per-candidate tuning. A deterministic
  l...

v0.9.0

Target: optional Spark execution and MLflow integration for Skyulf Core.
Development version: 0.9.0. This release has not been published; Spark node
execution, MLflow registry and Databricks delivery remain under development.

Changed

• Nested tuning now runs independent inner searches within outer training folds,
  with preprocessing refit inside each fold and a separate final model search.
  Optional inner-fold controls and saved outer evaluation results are connected
  across Core, Canvas and Databricks. Search budgets apply per search; nested
  threshold tuning is rejected until it can be evaluated within outer folds.

• Logistic Regression preserves explicit L1/L2/Elastic Net/unpenalized settings
  on older scikit-learn runtimes. The newer l1_ratio/C translation is applied
  only when the installed estimator uses that API, keeping tuning refits and
  ensemble components consistent with the requested penalty.

• Databricks quality-gate model-version tags now use Unity Catalog-compatible
  names. Post-selection ensemble CV removes the completed tuning control while
  preserving the selected component parameters.
  Automatic halving spaces leave the selected resource to the scheduler, and
  saved-model actions no longer expand editable training search recipes.

• Databricks ensemble recipes live in optional src/ensemble.py, separate from
  common search configuration. Named weights, calibration, stacking meta-learners
  and fixed component parameters are validated without silent Core fallbacks.
  Hard voting now supports prediction-only local artifacts and matching MLflow/SDK
  schemas. SGD is available as an ensemble component, matching the Canvas picker.

• Databricks setup now selects a Core tuning strategy directly, with automatic
  model search spaces, task-specific models/ensembles and default/custom controls.
  Shared CV refits preprocessing within training folds, preserves final holdout
  isolation and saves selected parameters/trials. Optional src/tuning.py
  overrides and bounded SHAP evidence are captured with the fitted artifact.
  Standalone tuning now prepares ensemble members and excludes temporal ordering
  metadata from required inference inputs; halving forwards resource bounds.

• Databricks model comparison supports optional absolute quality_gates
  alongside one selection metric. First champion and manual approval enforce
  every gate, with per-gate notebook/MLflow evidence and unchanged historical
  single-gate receipt hashes. Comparison validation and decisions now use
  focused helpers with explicit absolute-improvement semantics.

• Databricks lifecycle tasks restore saved custom preprocessing registrations
  before validating the training specification or running CV in a new process.
  Pinned recipes remain authoritative across task boundaries.

• Generated Databricks scoring uses a fixed run_score_notebook entrypoint
  without a training artifact directory. The role-based notebook API remains
  a compatibility adapter; fixed lifecycle phases and SDK APIs are preserved.

• Generated Databricks projects now carry a shorter setup/operator README and
  minimal preprocessing hooks. Custom Calculator/Applier tutorials live in the
  shared examples directory; saved single-file code remains replayable. README
  graph-contract instructions now match the generated lifecycle tasks.

• Databricks basic setup now uses defaults for advanced snapshot/split, sampling,
  CV and policy details, reducing default prompts from 33 to 26. Existing init
  files retain their values and validation; the setup guide explains overrides.

• Databricks comparison/decision tasks avoid a discarded source replay and reuse
  verified comparison metadata within its phase. Registration still rechecks its
  receipt immediately before mutation; decision retains fresh evidence and
  membership checks before alias changes.

• Databricks evidence and training-spec validation now use focused helpers;
  lifecycle completion and failure handling are separated while preserving
  validation order, durable receipts and original errors.

• Databricks lifecycle replay and approval now share saved training-spec parsing
  and verified evidence loading. Common result construction lives in the workflow
  layer, removing the task adapter's notebook dependency while preserving imports
  and operator/scoring output.

• SDK and durable Databricks training now share policy/CV validation, source and
  champion preparation, and bounded registry tags. Task receipts, SDK callbacks
  and existing champion compatibility checks retain their execution boundaries.

• First-candidate notebook reports now render a missing champion's null metrics
  as "No champion", preserving readable comparison and approval/rejection output.

• The Bundle lifecycle graph now has eight tasks: training/evaluation/registration
  and comparison/promotion each share a task. finalize_and_report joins both
  branches with ALL_DONE, closes failed training, and publishes a score request
  only after verifying successful saved evidence. Redundant edges and standalone
  bookkeeping notebooks were removed; the two serialized jobs are preserved.

• Bundle training uses one train action for manual and cron invocations;
  train_monthly has been removed. An unset training_version resolves the
  latest source snapshot once, while explicit versions remain pinned. Data
  windows remain independent of schedules, and explicit result cutoffs are
  preserved. Regenerate existing scheduled jobs with the matching wheel.

• The local Bundle exposes preparation, training/registration and comparison/decision
  as real tasks in the same serialized lifecycle job.
  Manual actions bypass training; tasks share pinned MLflow artifacts and
  verified phase evidence. Training finalization is independent of scoring,
  and the final decision/operator inputs appear in finalize_and_report.
  Regenerate the graph and notebooks with the matching wheel (graph contract 2).
  Lifecycle repairs/retries are rejected until uncertain effects are inspected.

• Local candidate training records its pinned source/window and original pipeline
  input in MLflow before reading data, splitting, CV or fitting. Runtime failures
  retain replay evidence on a FAILED run without publishing a model. Manual
  replay uses the original config so fixed cleanup is not prepended twice.

• Bundle training and scoring have independent optional cron, timezone and pause
  settings; selected schedules default to enabled. Rolling temporal training can
  choose its holdout duration, and result filtering can use a configurable delay
  in elapsed UTC hours. Manual replay retains explicit data boundaries.

• Databricks source periods compare UTC instants across repeated DST hours.
  Controlled champion reads verify the committed registry event; concrete model
  versions and registry URI types fail early when invalid. Concurrent MLflow
  experiment creation reuses the winning experiment without hiding other errors.
  Pre-split execution and preservation checks are separated into focused helpers.

• Fixed pre-split admission uses per-node validators and derives its supported
  node set from the same rule table. Validation behavior and errors are unchanged.

• Bundle pre-split recipes support validated fixed cleanup, deterministic
  Deduplicate and explicitly declared custom row filters in preprocessing.py.
  Saved models apply feature cleanup once to raw prediction inputs; target-only
  cleanup and training eligibility filters do not require prediction columns.
  Approval restores saved custom code before verifying the recipe and evidence.

• Text vectorizers preserve fitted feature columns and dtypes on empty evaluation
  partitions. TF-IDF and hashing recipes can now train through the local Bundle
  adapter without failing on its empty test partition, on pandas and Polars.

• Local retraining saves versioned cleanup evidence with the recipe, saved Python
  source identity, ordered survivor/train/holdout membership and row counts.
  Automatic and manual lifecycle replay verify this evidence against the model
  artifact; editing the current project file cannot replace its saved recipe.
  Training eligibility filters remain separate from prediction inputs.

• Bundle projects can define build_pre_split_steps() beside Python preprocessing
  to filter training rows with Core DropMissingRows and ManualBounds before
  splitting. Bounded reads and optional source samples stay ahead of cleanup;
  filter-only columns stay outside model inputs. Saved recipes and exclusion
  counts support the same holdout replay during model approval. Scoring does not
  apply training eligibility filters.

• Core lag/rolling now reject a missing declared sort column, and direct lag
  artifacts reject nonpositive/noninteger lags. Known current-target rolling is
  blocked regardless of split placement; backend admission reuses the Core rule.
  Temporal artifacts remain configuration-only, with caller-supplied history.

• Bundle date questions follow user-declared column representation without reading
  source data. Native timestamps skip parsing questions; date-only and text choices
  reveal only applicable format/timezone/midnight rules. Disabled date use, CV,
  scheduling and policy compute hide their dependent questions.

• Generated Bundle notebook tasks disable automatic retries, including the
  separate serverless auto-optimization retries that can register an extra
  candidate after a failed training task. Recovery remains explicit.

• Saved local model evaluation uses sequential joblib prediction to reproduce
  parallel forest metrics during exact registry-evidence replay. Training and
  ordinary batch inference retain their configured parallelism; approval checks
  a...

v0.8.24

• Model and data safety: redact credentials in diagnostics, publish model
  artifacts atomically, reject incomplete preprocessing and isolate S3 caches.
• Training and exports: align notebook execution with Canvas, save the target
  node's results, validate search/threshold inputs and require explicit temporal
  features. Keep connected ensemble parameters synchronized.
• Inference and monitoring: preserve quoted CSV records, exclude missing
  predictions from summaries, retain histogram tails and correct drift history,
  effective thresholds and exports.
• EDA and Canvas: preserve filter context, apply exact histogram filters,
  distinguish unavailable analysis from empty results, add scoped retries and
  correct decomposition, timeline, seasonality and export labels.
• Runtime reliability: reuse Redis publisher connections, keep health checks
  and prediction responsive, persist job descriptions and surface failures.
• Contract coverage: verify manual threshold provenance, JSON error fallback
  and legacy graph rejection; document cross-engine reproducibility limits.

v0.8.23

• Branched inference (OC-320): preserve raw columns until fitted encoders
  have consumed them, then apply final column removal and feature ordering.
  Existing numeric/OneHot/TF-IDF models can serve raw inputs without retraining.
• Deployment promotion (OC-278/311): validate model loading, predictor and
  preprocessing interfaces, and sklearn fitted state before replacing the active
  deployment. Roll back failed promotions. Resolve legacy artifact references
  through the configured permitted root for prediction and schema inspection.
• Preview execution (OC-279/307/308): run synchronous graph work in a worker
  thread with its own session and temporary artifacts. Direct Data Preview
  connections retain their upstream results; cyclic graphs return HTTP 400.
  Cancelled requests let ongoing worker operations finish before cleanup.
• Causal analysis and VIF (OC-274/287): exclude constant measurements before
  allocating causal feature slots or calculating VIF. Preserve diagnostics for
  useful variable columns and explain VIF omissions through existing alerts.
  Regenerate saved profiles to obtain the corrected diagnostics.
• Repeated profile filters (OC-304): retain cumulative filter metadata when
  reusing an analyzer, with independent snapshots for previous profiles.
• Alias value types (OC-298): normalize text aliases while preserving
  explicitly selected numbers, booleans and dates on both engines. Numeric
  0/1 remain numeric; cast them to strings first to map them to No/Yes.
  Rerun affected transformations from original data and refit downstream models
  if their training features depended on the former coercion.
• Advanced resampling settings (OC-301): honor custom SVC/KMeans estimators,
  NearMiss neighbor counts and worker limits on methods that support them.
  Rerun affected training jobs to apply settings previously ignored.
• sklearn adapter validation (OC-312): reject unsupported containers with
  an actionable error while preserving mixed-engine frames, arrays and target
  sequences. Select a train/test split before passing a SplitDataset to the adapter.
• Inference regression coverage (OC-246): replace the external-workspace
  smoke test with isolated, asserted preprocessing, reload, promotion and
  prediction exercises on both engines.
• Model fingerprints (OC-272): support fitted Gradient Boosting, HistGradient
  Boosting and SGD loss/RNG state in fingerprints and model cards. Keep supported
  compiled-loss identities stable across sklearn 1.8/1.9 and reject unknown state.
• Embedding model cache (OC-313): share one model load among concurrent
  callers in a process, release waiters on failure and allow immediate retries.
  Different model names can still load concurrently.
• EDA native types and plots (OC-259/260/288): retain usable profiles for
  Decimal, Time and List columns with explicit unavailable-statistics alerts;
  missing counts and samples remain available. Align time-series metrics to
  common timestamps with gaps. Date/time decomposition filters preserve native
  precision and timezone semantics, including distinct fractional-time buckets.
• Correlation omissions (OC-303): include excluded-column metadata when
  limiting correlation analysis to 20 numeric columns, and show that warning in
  the UI. Existing saved reports remain readable; regenerate them for metadata.
• Upload and pagination bounds (OC-306/309): preserve HTTP 413 for oversized
  monitoring uploads, check sizes in bounded chunks and parse the existing upload
  spool. Reject invalid page offsets and row limits before reads or queries;
  explicit samples allow up to 50,000 rows, while page limits follow configuration.
• Canvas editing (OC-227/314/315/316): record one undo step per completed
  single/group drag, preserve history during edge selection, block paste in
  read-only mode and reuse dataset nodes when reopening their source links.
  Ignore equivalent settings writes so reopening a tuned model's panel does
  not add invisible undo steps or discard redo history.
• Canvas request lifetimes (OC-223/226): preserve newly typed drift notes
  and current alert details when earlier requests finish. Load Segmentation
  defaults into the current model/node settings without restoring stale
  references, replacing user parameters or updating an unmounted panel.
• Jobs accessibility (OC-225): keep valid dialog names in history and detail
  views, label Back/Close actions and retain keyboard focus within the drawer.
• Scaling ranges (OC-318): show empty bounds as invalid in Canvas, preserve
  that state through saved graphs, and identify the field in Issues. Reject
  malformed/nonfinite Core ranges with actionable errors while retaining valid
  JSON/Python numeric ranges and fitted-artifact types.
• Binary tuning metrics (OC-253): align named F1/precision/recall/PR-AUC
  with evaluation and threshold tuning's sorted-last positive class. For
  labels {1,2}, future searches score class 2 consistently. Explicit scorer
  choices and existing fitted models retain their behavior.
• Optuna pruning (OC-269): stop XGBoost/LightGBM trials during boosting,
  eligible direct incremental models between epochs, and other models between
  completed CV folds. Preserve fold-local preprocessing, selected scoring metrics
  and complete-trial-only refit. A single holdout needs an iteration hook.
  Canvas checks the current model, search choices, CV and connections, explains
  the available mode and disables unavailable pruners with a reason. A separate
  tooltip lists model support. Apply saves the choice; checking or closing
  settings adds no undo step.
• Filtered tuning validation (OC-251): keep validation features and targets
  aligned after fold preprocessing in ordinary Optuna and both Halving searches.
  Apply filtering once per score, preserve original classification labels and
  probability columns, and leave fitted preprocessing intact. Scores describe
  the retained validation rows; rerun affected searches to obtain valid results.
• Logistic Regression penalties (OC-319): keep direct fits, candidate scores
  and final refits consistent. Explicit L1/L2 selections override stale mixing
  ratios; Elastic Net keeps its configured ratio. Preserve fixed settings when
  searching across penalties and reject unknown names. Rerun affected searches.
• Search defaults (OC-102): provide random/grid candidate spaces for KMeans,
  MiniBatchKMeans, Gaussian Mixture and Birch. Voting Regressor exposes fixed
  top-level settings and directs users to Ensemble base-model tuning.
• Canvas validation (OC-56/292): cancel schema-preview requests on graph
  changes and unmount, and ignore their late responses. Reject clustering or
  nested Ensemble outputs as ensemble bases; saved invalid connections appear
  in Issues and block the affected training/tuning submission.
• Leakage example (OC-213): correct notebook configuration and validation
  partition types while retaining the executable leakage checks.
• EDA recommendations (OC-50/111): keep Boolean/binary integer target
  classification and balance advice independent of sample size, honoring
  explicit Regression. Avoid numeric transformations of class labels and offer
  conditional encoding advice for repeated integer category codes.
• Outlier populations (OC-302): include analyzed/total row metadata and
  label sample counts and percentages in the UI and console. Older reports
  remain readable with an unknown denominator; regenerate them for metadata.
• Drift value types (OC-47): preserve fractional and wider numeric values
  when comparing against an integer reference. Report incompatible types or
  partly unparseable numeric text as explicit type drift with guidance, instead
  of losing observations. Reject infinite inputs with a column-specific error
  before producing invalid scores. Rerun affected checks for corrected measurements.
• Date features (OC-255): new fitted steps extract date/time features in UTC
  consistently across engines, including mixed DST offsets. Naive inputs keep
  their clock values. Saved artifacts without the policy retain their original
  behavior; refit the pipeline to adopt the UTC contract.
• Finite JSON results (OC-286): write NaN and infinities as null in profile,
  preview, training and tuning result JSON, including nested typed statistics,
  NumPy values and Decimal conversions. Preserve caller-owned in-memory results;
  existing stored reports are not migrated.
• Registry log integrity (OC-289): escape controls in job identifiers and
  fully rendered exception chains while preserving credential redaction and
  HTTP error behavior. Traceback source lines with escaped controls remain redacted.
• Node and configuration coverage (OC-11/80): require smoke tests to fit
  meaningful artifacts and execute all 34 selected node appliers. Extend malformed
  configuration and JSON mapping tests; ignore unmatchable numeric replacement
  keys on both engines while still applying valid mappings.
• Prediction row alignment (OC-281): reject filtering/expansion during
  prediction with stage names and row counts. Reject reordered inputs in built-in
  LagFeatures/RollingAggregate steps. Deployment returns HTTP 400 without a partial
  result; ordinary transforms, CV and threshold fitting keep their semantics.
  Preserve valid NumPy/sparse outputs and row-preserving clipping.
• Atomic job submission (OC-277/310): reserve duplicate checks and job/version
  writes together across API processes. Keep a single in-process lock while
  owners/waiters remain, release failed/cancelled reservations and reject unknown
  job types with HTTP 400. Preserve valid later submissions and branch separation.
  No database migration is required; PostgreSQL uses default READ COMMITTED.
• Engine isolation and empty features (OC-64/65): make fal...