@zhuoyuezs/ml-platform 0.1.0

package/scripts/main.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const path = require("path");
+const { spawnSync } = require("child_process");
+const {
+  doctor,
+  install,
+  parseOptions,
+  status,
+} = require("./lib");
+
+const MANAGEMENT_COMMANDS = new Set(["install", "upgrade", "status", "doctor"]);
+const BUSINESS_ENTRY = path.resolve(__dirname, "..", "runtime", "business-client", "src", "cli.js");
+
+function usage() {
+  return `用法:
+  ml-platform install [--agent codex|pi|custom] [--scope user|project] [--skills-dir PATH] [--project-dir PATH] [--state-dir PATH] [--bin-dir PATH] [--upgrade] [--allow-downgrade]
+  ml-platform upgrade [install options]
+  ml-platform status  [--agent codex|pi|custom] [--scope user|project] [--skills-dir PATH] [--project-dir PATH] [--state-dir PATH] [--bin-dir PATH]
+  ml-platform doctor  [status options] [--api-url URL]
+  ml-platform <business-command> [args]
+
+安装管理命令:
+  install, upgrade, status, doctor
+
+其余已注册业务命令由同一份 JavaScript Business CLI 执行。
+`;
+}
+
+function printJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function loadBusinessCommands() {
+  try {
+    const { BUSINESS_COMMANDS } = require(BUSINESS_ENTRY);
+    if (!(BUSINESS_COMMANDS instanceof Set)) throw new Error("BUSINESS_COMMANDS export is missing");
+    return BUSINESS_COMMANDS;
+  } catch (error) {
+    throw new Error(`Business CLI 不完整: ${error.message}`);
+  }
+}
+
+function dispatchBusiness(argv) {
+  const commands = loadBusinessCommands();
+  if (!argv.some((arg) => commands.has(arg))) {
+    throw new Error(`未知命令: ${argv.find((arg) => !arg.startsWith("-")) || argv[0]}`);
+  }
+  const result = spawnSync(process.execPath, [BUSINESS_ENTRY, ...argv], {
+    stdio: "inherit",
+    env: process.env,
+  });
+  if (result.error) throw result.error;
+  return result.status === null ? 1 : result.status;
+}
+
+function main(argv) {
+  const [command, ...rest] = argv;
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    process.stdout.write(usage());
+    return 0;
+  }
+  if (!MANAGEMENT_COMMANDS.has(command)) return dispatchBusiness(argv);
+
+  const options = parseOptions(rest);
+  if (command === "install" || command === "upgrade") {
+    if (command === "upgrade") options.upgrade = true;
+    printJson(install(options));
+    return 0;
+  }
+  if (command === "status") {
+    const result = status(options);
+    printJson(result);
+    return result.ok ? 0 : 1;
+  }
+  const result = doctor(options);
+  printJson(result);
+  return result.ok ? 0 : 1;
+}
+
+if (require.main === module) {
+  try {
+    process.exitCode = main(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`${JSON.stringify({ ok: false, error: error.message }, null, 2)}\n`);
+    process.exitCode = 2;
+  }
+}
+
+module.exports = { BUSINESS_ENTRY, MANAGEMENT_COMMANDS, dispatchBusiness, main, usage };

package/skills/feature-management/SKILL.md

@@ -0,0 +1,265 @@
+---
+name: feature-management
+description: Manage projects, versioned business feature assets, dataset rowsets and endpoint eligibility, and causal realtime feature reads through the deployed ML Platform API using the ml-platform CLI installed with the same release. Use when a business user asks an agent to manage an empty Project, define or change Parameter source contracts, author/package/register an Operator wheel, define single-column Features, order a FeatureSet, create a DatasetManifest or catalog, configure training/validation/test rowsets or abnormal-data endpoint exclusion, configure realtime freshness policy, run catalog dry-run/apply, build a dataset, fetch one inference row, or inspect an artifact without downloading the platform source repository. Do not use for model training, versioned Registry asset deletion, image builds, or Kubernetes deployment.
+---
+
+# Feature Management
+
+Build the public asset chain without bypassing its versioned contracts:
+
+```text
+Parameter -----> Feature
+Operator ------> Feature -> FeatureSet -> DatasetManifest -> DatasetArtifact
+```
+
+Treat `Recipe` and public `Feature.compute` as removed. Treat `computation_hash` as internal execution metadata, never as a business-managed asset.
+
+## Load The Right Context
+
+1. Resolve the Skill root as the directory containing this `SKILL.md`.
+2. Read [references/contracts.md](references/contracts.md) before creating or changing JSON assets.
+3. Read [references/operator-authoring.md](references/operator-authoring.md) whenever creating or changing Operator code or a wheel.
+4. Read [references/commands.md](references/commands.md) before discovering assets, validating, publishing, building, fetching realtime data, or downloading.
+5. Use [assets/catalog-template](assets/catalog-template) as a copyable starting point for a new end-to-end catalog. Rename every `example_*` identifier and update every referenced path before validation.
+
+## Initialize The Client
+
+Use the `ml-platform` executable on `PATH` for every platform command. The formal distribution contract requires the npm release to install the CLI and this Skill together; that packaging stage is not implemented yet. The Skill does not contain a second CLI runtime, launcher, or installer. During repository development, provide the current JavaScript CLI through an isolated test `PATH`.
+
+Before any platform operation, verify the executable and its version:
+
+```bash
+command -v ml-platform
+ml-platform version
+```
+
+If the executable is missing or cannot start, stop and report that the ML Platform release installation is incomplete. Do not download a client, search for a repository checkout, or fall back to another executable.
+
+Before any server-profile discovery, dry-run, publication, build, or artifact
+operation, configure the deployed API URL exactly as follows:
+
+```bash
+ml-platform configure --api-url http://10.36.9.212:30620
+ml-platform --profile server health
+```
+
+Use `http://10.36.9.212:30620` when operating against the current deployed
+environment. Placeholder host and port values elsewhere in the references are
+generic templates, not this environment's configured target. The API is
+unauthenticated, so access it only from the approved internal network.
+
+Install and upgrade the CLI and Skill only through the explicit commands provided by `@zhuoyuezs/ml-platform`. Restart the Agent session after a successful Skill upgrade so the definition is reloaded. Never copy files over an installed Skill directory manually.
+
+## Establish Intent
+
+Collect only missing information. Do not invent a source table, source field, formula, time boundary, unit, valid range, missing-data rule, or owner.
+
+Confirm:
+
+- the target project (namespace) for the assets; use the built-in `default` only when the user has no dedicated project. On creation the project comes from the optional `project` field in each asset spec (defaults to `default`); reads and filters use the `--project` command option;
+- business meaning, stable asset names, owner, and intended consumers;
+- Parameter source adapter and credential-free source mapping;
+- feature formula, exact Parameter dependencies, windows, inclusion rules, rounding, null behavior, and output dtype;
+- whether an approved Operator already implements the formula;
+- FeatureSet column order;
+- dataset mode, read policy, time range, grid, prediction horizon/cutoff contract, and explicit Parameter outputs;
+- named training/validation/test rowsets, abnormal windows, endpoint-policy scope,
+  and the model context lookback used to decide endpoint eligibility;
+- realtime freshness and missing-input policy when serving inference data;
+- target profile/API and whether the user authorizes publish and/or build actions.
+
+Separate preparation from mutation. Creating files and running local tests or `apply --dry-run` does not authorize publishing a wheel, changing the Registry, or submitting a build Job.
+
+## Discover Existing Assets
+
+Check the selected profile and list existing Parameter, Operator, Feature, FeatureSet, and Dataset versions before choosing names. Scope discovery to the target project with `--project`, because the true registry key is `project/name:version` and the same `name:version` may exist independently under another project. Registry list commands are paginated; search by stable identifier or follow every page until `offset + len(items) >= total`. Reuse an exact immutable version only when its full content matches. Never reference an asset in another project; cross-project references are rejected.
+
+Create a new version when source semantics, formula code, config meaning, inputs, output dtype, time behavior, quality rules, or column order change. Never overwrite an immutable version or use suffixes such as `new`, `final`, or `test2`.
+
+## Upgrade Dependency Chains
+
+Treat a version change as a release of its affected reverse-dependency closure, not as an isolated asset bump.
+
+1. Record the intended old-to-new version mapping and the semantic reason for every changed asset.
+2. Follow exact references from the changed asset through every affected downstream consumer. For a Parameter change, publish a new Operator version when its input schema names that Parameter version, then new versions of every affected Feature, FeatureSet, and DatasetManifest. For an Operator change, start with its affected Features.
+3. Republish only the affected closure, but explicitly list and justify every downstream asset intentionally retained on an older dependency.
+4. Keep every reference exact. Never rewrite an existing immutable version, infer `latest`, or assume that increasing a Feature or FeatureSet version also upgrades its dependencies.
+5. Treat `apply --dry-run` as an existence and structural-compatibility check. It does not prove that the declared versions are the intended business release.
+
+Use this dependency order for an affected chain:
+
+```text
+Parameter -> Operator -> Feature -> FeatureSet -> DatasetManifest
+```
+
+## Build The Catalog
+
+Keep one business domain in one user-owned catalog directory:
+
+```text
+<catalog>/
+  catalog.json
+  parameters/
+  operators/
+  operator_package/
+  features/
+  feature_sets/
+  datasets/
+```
+
+Keep platform demos and V95 built-ins unchanged. Do not put unrelated business assets under `src/data_platform_demo/builtin_catalogs/v95`.
+
+### Define Parameters
+
+Create one stable, versioned source contract for each independently readable value. Keep credentials out of JSON. Use only supported direct adapters and explicit source identity. Put source data validity in `quality_rules`; put dataset-specific transformations in preprocess Operators.
+
+Use Parameter `rounding` when every consumer must receive the same fixed-point value. The platform applies `mode` (`half_up` or `half_even`) and `decimals` after source normalization and before quality checks, source caching, replay, and Operator execution. Prefer an unrounded source expression, do not repeat the same rounding in an Operator, and publish a new Parameter plus its affected reverse-dependency closure when the rule changes.
+
+Do not represent a rolling mean, lag, ratio, trend, or model input as a Parameter. Those are Features.
+
+### Define Operators
+
+First reuse a registered Operator if its version, input schema, output schema, formula semantics, and runtime contract match exactly.
+
+When a new Operator is required:
+
+1. Write a standalone pure-Python package with a `module:function` entrypoint.
+2. Make the Feature entrypoint accept one context and return a pandas DataFrame.
+3. Consume only declared `context.inputs` and `context.metric_frames`.
+4. Return `event_time` exactly equal to `context.target_times` plus the requested physical output columns.
+5. Implement explicit causal boundaries; never use future rows accidentally.
+6. Keep execution deterministic, network-free, credential-free, and bounded by `timeout_seconds`.
+7. Add formula, boundary, missing-value, requested-output, and ordering tests.
+8. Build a `py3-none-any` wheel and reference it from `catalog.json`.
+9. Leave `code_hash`, `package_uri`, and `code_artifact` null in the draft spec; catalog publication fills them from the uploaded wheel.
+
+Use a meaningful immutable `function_hash`. Change the Operator version whenever executable behavior changes.
+
+### Define Features
+
+Create one JSON file per single output column. Bind exactly one Operator version and physical `output_column`. List only the Parameter versions actually required by that column's formula.
+
+Features may share the same Operator and config. The planner will merge their exact inputs and call the Operator once per computation group. Do not duplicate every Operator input into every Feature merely to make schemas look uniform.
+
+### Define The FeatureSet
+
+Reference immutable Feature versions in the exact consumer column order. Keep the list nonempty and duplicate-free. Do not copy formulas, inputs, or Operator configuration into the FeatureSet.
+
+### Define The DatasetManifest
+
+Reference exactly one FeatureSet. Use `parameters` only for Parameter columns that must also appear explicitly in `parameter_dataset.parquet`; Feature dependencies are resolved automatically.
+
+Declare one dataset-wide `prediction` contract when Features use a forecast cutoff. Operators consume `context.cutoff_times`; do not copy the same prediction horizon into every Feature config. Check the selected Operator's `input_schema.prediction` limits and satisfy an explicit-horizon requirement before publishing or building.
+
+Use `snapshot` for reproducible training data, `as_of` for historical visibility replay, and `latest` for current inference-style reads. Use a fresh `dataset_version` when validating a new release or intentionally requesting a new immutable dataset contract.
+
+Treat row construction and endpoint eligibility as separate contracts. Use
+`rowset_splits` to label candidate target instants such as `training`,
+`validation`, and `test`. When abnormal observations should make only selected
+endpoints unusable, keep `abnormal_windows.policy=mark_only` and declare
+`endpoint_policy`; do not delete canonical Feature rows. Declare
+`endpoint_policy.context_lookback` from the model sequence contract, independently
+of Operator source-history requirements. Read [references/contracts.md](references/contracts.md)
+for the cutoff formula, half-open overlap boundaries, scope behavior, and
+`rowset_membership.parquet` schema.
+
+For realtime inference, declare `realtime_fetch` only when its effective policy
+must be part of the contract; leaving it unset preserves existing manifest
+hashes. Keep `allow_missing=false` unless the user explicitly accepts missing
+required inputs. Read [references/contracts.md](references/contracts.md) for the
+freshness, tail-edge, gap-fill, and rowset contracts.
+
+## Validate Before Publishing
+
+Run, in order:
+
+1. Operator unit tests.
+2. Wheel build and wheel filename verification.
+3. Catalog path, schema, dependency, immutability, and package validation with `apply --dry-run` against the same target profile intended for publication.
+4. Compare the catalog's exact dependency closure with the intended old-to-new version mapping. Reject any affected downstream reference that still points to an old version unless its retention is explicit and justified.
+5. A human-readable summary of planned new, unchanged, retained, and conflicting assets.
+
+Stop on any error. Do not weaken schema validation, fabricate a missing dependency, change an existing version in place, or switch profiles to make validation pass.
+
+## Publish And Build
+
+Publish only after the user explicitly approves Registry and wheel changes. Use catalog `apply` so publication follows Parameter -> Operator -> Feature -> FeatureSet -> Dataset order.
+
+After publication, resolve every new DatasetManifest and compare its exact Parameter, Operator, Feature, and FeatureSet versions with the pre-publication mapping. Stop if an affected old key or any unexpected version remains. Resolve the manifest before building. Submit a build only when requested. For server builds, wait for the terminal Job state and download the exact artifact by `dataset_id + manifest_hash`.
+
+Do not delete versioned Registry assets, cancel Jobs, rebuild images, modify Kubernetes, or change service configuration as part of this workflow unless the user separately and explicitly requests that action. An empty Project may be soft-deleted only on an explicit request; rely on the server to reject deletion when resources still exist.
+
+## Fetch Realtime Inference Data
+
+Use `fetch-inference-data` only when the user requests one causal-cutoff read.
+Confirm the cutoff and prediction horizon. The command must call
+`POST /inference-data/fetch`; it must not submit a batch build, write parquet, or
+publish a DatasetArtifact.
+
+Verify that the response reports the requested cutoff and derived target time,
+`uses_post_cutoff_data=false`, `contract.manifest_hash`, a replayable `as_of`
+manifest, and per-Parameter freshness evidence. Report tolerated missing or
+gap-filled inputs as degraded freshness, not as a normal read.
+
+## Verify The Artifact
+
+Require all of the following before reporting success:
+
+- Job status is `succeeded`;
+- `validation.json` has `ok: true` and no errors;
+- `validation.feature_nulls` is read, not skipped: `ok: true` can coexist with
+  null model inputs reported as warnings. Report `total_null_cells`, and for each
+  affected Feature its `null_count`, event-time range, and upstream Parameter
+  keys. Set `output.strict_feature_nulls` when any null should fail the build
+  instead;
+- row count is nonzero and matches the requested half-open time grid when no
+  documented row filtering applies. When `abnormal_windows` uses a drop policy,
+  reconcile the lower count against `abnormal_windows.rows_before`,
+  `rows_after`, and `dropped_rows` in the resolved manifest. With `mark_only`,
+  require `dropped_rows=0` and preserve the full candidate rowset;
+- when `endpoint_policy` is set, require `abnormal_windows.policy=mark_only`,
+  preserve every candidate row in `feature_dataset.parquet` and
+  `parameter_dataset.parquet`, and require `rowset_membership.parquet`;
+- verify membership counts globally and by rowset, inspect every ineligible
+  row's `reason_codes`, and confirm that the configured compatibility column in
+  both canonical datasets equals `policy_applied AND eligible`; it is false for
+  pass-through rowsets outside the policy scope;
+- for a partitioned build, verify that merged membership, endpoint-policy
+  quality statistics, lineage, and `policy_hash` match a single build of the
+  same manifest;
+- `feature_dataset.parquet` starts with `event_time`, optional `furnace_id`, then FeatureSet columns in exact order;
+- resolved lineage records every Parameter version, Feature version, Operator version, code hash, and computation hash, exactly matches the approved dependency-version mapping, and contains no stale affected key;
+- artifact lineage contains the same approved dependency closure as the resolved manifest;
+- execution metadata shows the expected number of computation groups and requested physical columns;
+- when `source_read` is set, `latency_stats.fetch_timing_summary` shows the chunk
+  windows tiling the fetch range, and any retries are accounted for;
+- missing values and warnings are reported, not silently repaired.
+
+The manifest hash returned by `resolve-manifest` is the artifact key: it stays
+the same after the build, so it is usable for cache reuse and polling before
+submission. Distinguish the two lookup failures rather than treating both as "not
+ready" — `422` with `invalid_artifact_key` means the key can never name an
+artifact, while `404` with `artifact_not_found` or `artifact_not_built` means
+nothing is built under a valid key, and lists any in-flight Jobs.
+
+State the current runtime truth: first-phase public builds execute registered Python Operators through `FeatureOperatorRunner`. Do not claim that Chronon compile/backfill or Chronon-native feature computation occurred unless the artifact contains and passes those explicit execution records.
+
+## Report The Outcome
+
+Return a concise business-facing summary containing:
+
+```text
+catalog and version
+new / unchanged assets by type
+planned versus resolved dependency versions and any explicitly retained old versions
+Operator package filename and SHA-256
+FeatureSet and ordered feature count
+dataset id, version, manifest hash, and Job id
+row and column counts
+rowset candidate / policy-applied / eligible / ineligible counts when endpoint_policy is declared
+validation status, warnings, and missing-data summary
+artifact location
+actual compute backend
+```
+
+If the work stops before publication, distinguish generated files, locally validated files, dry-run validation, and remotely published assets.

package/skills/feature-management/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "特征与实时取数管理"
+  short_description: "管理版本化 Parameter、Operator、Feature、数据集与实时推理取数"
+  default_prompt: "Use $feature-management to manage versioned feature assets, build datasets, or fetch one causal realtime inference row through the platform API."

package/skills/feature-management/assets/catalog-template/catalog.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": "ml_data_platform.catalog/v1",
+  "name": "example_business_feature_catalog",
+  "version": "v1",
+  "parameters": [
+    "parameters/example_temperature.v1.json"
+  ],
+  "operators": [
+    {
+      "spec": "operators/example_temperature_features.v1.json",
+      "package": "operator_package/dist/business_feature_operator_template-1.0.0-py3-none-any.whl"
+    }
+  ],
+  "features": [
+    "features/example_temperature_mean_5m.v1.json"
+  ],
+  "feature_sets": [
+    "feature_sets/example_temperature_core.v1.json"
+  ],
+  "datasets": [
+    "datasets/example_temperature_training.v1.json"
+  ]
+}

package/skills/feature-management/assets/catalog-template/datasets/example_temperature_training.v1.json

@@ -0,0 +1,24 @@
+{
+  "schema_version": "ml_data_platform.dataset_manifest/v1",
+  "dataset_id": "example_temperature_training",
+  "dataset_version": "v1",
+  "mode": "training",
+  "read_policy": "snapshot",
+  "time_range": {
+    "start": "2026-07-01T00:00:00+08:00",
+    "end": "2026-07-02T00:00:00+08:00",
+    "grid": "10min"
+  },
+  "parameters": [],
+  "feature_set": {
+    "name": "example_temperature_core",
+    "version": "v1"
+  },
+  "preprocess": [],
+  "output": {
+    "format": "parquet",
+    "include_stats": true,
+    "include_lineage": true,
+    "engine": "chronon"
+  }
+}

package/skills/feature-management/assets/catalog-template/feature_sets/example_temperature_core.v1.json

@@ -0,0 +1,13 @@
+{
+  "schema_version": "ml_data_platform.feature_set/v1",
+  "name": "example_temperature_core",
+  "version": "v1",
+  "features": [
+    {
+      "name": "example_temperature_mean_5m",
+      "version": "v1"
+    }
+  ],
+  "owner": "replace_with_business_owner",
+  "description": "Ordered example temperature features."
+}

package/skills/feature-management/assets/catalog-template/features/example_temperature_mean_5m.v1.json

@@ -0,0 +1,21 @@
+{
+  "schema_version": "ml_data_platform.feature/v1",
+  "name": "example_temperature_mean_5m",
+  "version": "v1",
+  "inputs": [
+    {
+      "parameter": "example_temperature",
+      "version": "v1"
+    }
+  ],
+  "operator": "example_temperature_features",
+  "operator_version": "v1",
+  "config": {
+    "window": "5min"
+  },
+  "output_column": "example_temperature_mean_5m",
+  "output_dtype": "float64",
+  "offline_online_supported": false,
+  "owner": "replace_with_business_owner",
+  "description": "Mean example temperature in the causal interval (target-5min, target]."
+}

package/skills/feature-management/assets/catalog-template/operator_package/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "business-feature-operator-template"
+version = "1.0.0"
+requires-python = ">=3.10"
+dependencies = ["pandas>=2.3.3"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/business_feature_operator_template"]

package/skills/feature-management/assets/catalog-template/operator_package/src/business_feature_operator_template/__init__.py

@@ -0,0 +1,39 @@
+"""Example business Feature Operator. Replace names and formulas before use."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+
+SUPPORTED_OUTPUTS = {"example_temperature_mean_5m"}
+
+
+def compute_features(context: Any) -> pd.DataFrame:
+    requested = list(dict.fromkeys(context.requested_output_columns))
+    unknown = sorted(set(requested) - SUPPORTED_OUTPUTS)
+    if unknown:
+        raise ValueError(f"unsupported output columns: {unknown}")
+
+    input_keys = {item.parameter: item.key for item in context.inputs}
+    parameter_key = input_keys.get("example_temperature")
+    if parameter_key is None:
+        raise ValueError("example_temperature input is required")
+
+    frame = context.metric_frames[parameter_key]
+    values = pd.to_numeric(
+        frame.set_index("timestamp")["value"],
+        errors="coerce",
+    ).sort_index()
+    if values.index.has_duplicates:
+        values = values.groupby(level=0).last()
+
+    window = pd.Timedelta(str(context.config["window"]))
+    output: dict[str, object] = {"event_time": context.target_times}
+    if "example_temperature_mean_5m" in requested:
+        output["example_temperature_mean_5m"] = [
+            values.loc[(values.index > target - window) & (values.index <= target)].mean()
+            for target in context.target_times
+        ]
+    return pd.DataFrame(output)

package/skills/feature-management/assets/catalog-template/operator_package/tests/test_operator.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import unittest
+from types import SimpleNamespace
+
+import pandas as pd
+
+from business_feature_operator_template import compute_features
+
+
+class ComputeFeaturesTest(unittest.TestCase):
+    def context(self, requested: list[str] | None = None) -> SimpleNamespace:
+        source = pd.DataFrame(
+            {
+                "timestamp": pd.DatetimeIndex(
+                    [
+                        "2026-07-01 09:54:00",
+                        "2026-07-01 09:56:00",
+                        "2026-07-01 10:00:00",
+                        "2026-07-01 10:01:00",
+                    ]
+                ),
+                "value": [10.0, 20.0, 30.0, 40.0],
+            }
+        )
+        return SimpleNamespace(
+            requested_output_columns=requested or ["example_temperature_mean_5m"],
+            inputs=[
+                SimpleNamespace(
+                    parameter="example_temperature",
+                    key="example_temperature:v1",
+                )
+            ],
+            metric_frames={"example_temperature:v1": source},
+            target_times=pd.DatetimeIndex(
+                ["2026-07-01 10:00:00", "2026-07-01 10:02:00"]
+            ),
+            config={"window": "5min"},
+        )
+
+    def test_uses_open_left_and_closed_right_window(self) -> None:
+        result = compute_features(self.context())
+
+        self.assertEqual(
+            list(result.columns),
+            ["event_time", "example_temperature_mean_5m"],
+        )
+        self.assertEqual(result["example_temperature_mean_5m"].tolist(), [25.0, 35.0])
+
+    def test_rejects_unknown_requested_output(self) -> None:
+        with self.assertRaisesRegex(ValueError, "unsupported output columns"):
+            compute_features(self.context(["unknown_feature"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/feature-management/assets/catalog-template/operators/example_temperature_features.v1.json

@@ -0,0 +1,43 @@
+{
+  "schema_version": "ml_data_platform.operator/v1",
+  "name": "example_temperature_features",
+  "version": "v1",
+  "type": "feature",
+  "function_hash": "example_temperature_features.formulas.v1",
+  "entrypoint": "business_feature_operator_template:compute_features",
+  "code_hash": null,
+  "package_uri": null,
+  "code_artifact": null,
+  "input_schema": {
+    "parameters": [
+      "example_temperature:v1"
+    ]
+  },
+  "output_schema": {
+    "columns": [
+      "event_time",
+      "example_temperature_mean_5m"
+    ]
+  },
+  "config_schema": {
+    "properties": {
+      "window": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "window"
+    ]
+  },
+  "runtime": {
+    "engine": "python_entrypoint",
+    "network": "none"
+  },
+  "resources": {
+    "timeout_seconds": 60
+  },
+  "deterministic": true,
+  "supports_batch": true,
+  "supports_online": false,
+  "owner": "replace_with_business_owner"
+}

package/skills/feature-management/assets/catalog-template/parameters/example_temperature.v1.json

@@ -0,0 +1,57 @@
+{
+  "schema_version": "ml_data_platform.parameter/v1",
+  "name": "example_temperature",
+  "display_name": "Example temperature",
+  "version": "v1",
+  "data_type": "time_series",
+  "unit": "degC",
+  "expected_frequency": "1min",
+  "source": {
+    "adapter": "postgresql_direct",
+    "mode": "direct_column",
+    "schema": "process_data",
+    "table": "sensor_readings",
+    "time_column": "event_time",
+    "value_column": "temperature",
+    "metric_name": "example_temperature",
+    "unit_column": "unit",
+    "filters": {
+      "furnace_id": "BF12"
+    }
+  },
+  "time_semantics": {
+    "event_time_field": "event_time",
+    "ingested_at_field": "ingested_at",
+    "timezone": "Asia/Shanghai",
+    "availability": {
+      "strategy": "source_field",
+      "field": "ingested_at",
+      "accuracy": "exact"
+    }
+  },
+  "availability_sla": {
+    "max_delay": "PT10M"
+  },
+  "value_field": "value",
+  "quality_rules": {
+    "valid_range": [0.0, 2000.0],
+    "allow_missing": true,
+    "rules": [
+      {
+        "id": "finite_source_values",
+        "stage": "normalized_source",
+        "check": {
+          "type": "finite"
+        },
+        "acceptance": {
+          "max_violation_rate": 0.0,
+          "min_evaluated_rows": 1,
+          "min_comparable_rate": 0.0
+        },
+        "enforcement": "fail",
+        "description": "Reject non-finite source values before preprocessing."
+      }
+    ]
+  },
+  "owner": "replace_with_business_owner"
+}