@zhuoyuezs/ml-platform 0.2.9 → 0.2.10

package/checksums.json

@@ -27,8 +27,8 @@
     },
     {
       "path": "runtime/business-client/src/cli.js",
-      "sha256": "sha256:c235053473fb55737dc2c6269a556ed9e4206b074327c0acaf8ac663f1ea00da",
-      "size_bytes": 79409
+      "sha256": "sha256:143ce6e82d861fae647384e3617ec0f0222fef7c8e7b546ca67393fba8bd08b5",
+      "size_bytes": 85198
     },
     {
       "path": "runtime/business-client/src/config.js",
@@ -42,23 +42,28 @@
     },
     {
       "path": "skills/data-source-exploration/SKILL.md",
-      "sha256": "sha256:1f1f89d4ca41c3f7b206287e983027f50f65e462897584511259067fe94f2707",
-      "size_bytes": 5631
+      "sha256": "sha256:63086689eac598ba9683d8dc63921b6ce13780973870e5ec346f69918892c5ed",
+      "size_bytes": 6260
     },
     {
       "path": "skills/data-source-exploration/agents/openai.yaml",
-      "sha256": "sha256:5c7f7d497ad7738c672b8ee906d514284a2f2583a854f8fa487708a75836256f",
-      "size_bytes": 299
+      "sha256": "sha256:15c93196536ff0eef2cf63940bee5eee852c9ccd55f394253fd98647f235b2eb",
+      "size_bytes": 348
+    },
+    {
+      "path": "skills/data-source-exploration/references/data-platform.md",
+      "sha256": "sha256:f65ff27fcd3f2e18baa34ae103984bc3a0adbf9fbbcf28d652ed41f89c11e44a",
+      "size_bytes": 5865
     },
     {
       "path": "skills/feature-management/SKILL.md",
-      "sha256": "sha256:1435e380ede73fc9775bd0579ff9df08baf07b4eed8b1bbc174b5b394a72914f",
-      "size_bytes": 35359
+      "sha256": "sha256:f7777f43adf83cf4ee663c1e993f2f3d6221054f02e3cdcd24e65db36990141e",
+      "size_bytes": 36116
     },
     {
       "path": "skills/feature-management/agents/openai.yaml",
-      "sha256": "sha256:a4c69cb062dc52749f0c0c96ad2d16f91f83ecedb44f78dcf662ef220273f24d",
-      "size_bytes": 325
+      "sha256": "sha256:db2a9ebc7926370264e06b8e5767105415bb8a09a2dda08a7cf418a6e3b39bb0",
+      "size_bytes": 366
     },
     {
       "path": "skills/feature-management/assets/catalog-template/catalog.json",
@@ -107,14 +112,19 @@
     },
     {
       "path": "skills/feature-management/references/commands.md",
-      "sha256": "sha256:375f953bac0263f9a40d217c99f029226d2a838c9510fce8d6e2324b8f548fb1",
-      "size_bytes": 18288
+      "sha256": "sha256:248721ee995ebb20ea44a263f528e1af6004f7af55d31503185f6269744dee8d",
+      "size_bytes": 18829
     },
     {
       "path": "skills/feature-management/references/contracts.md",
       "sha256": "sha256:717b81364f8508cd73d52f18d7b5dd012a3f3638921a8a5a93c41991a4f27998",
       "size_bytes": 38182
     },
+    {
+      "path": "skills/feature-management/references/data-platform-mapping.md",
+      "sha256": "sha256:fef06e1e1918132336789aa6d430a501324fc3f3f2241817322740a8dd20054a",
+      "size_bytes": 7421
+    },
     {
       "path": "skills/feature-management/references/operator-authoring.md",
       "sha256": "sha256:68ec5861800a6623db8e3cfae8e3363493c54772c4719d60dc66e4f4f0d3a347",
@@ -122,18 +132,18 @@
     },
     {
       "path": "skills/feature-management/references/platform-capability-guide.md",
-      "sha256": "sha256:6acb35f57e1bd6385702b6114e96c0ed1db34c9650d18658f74f212af9f91d14",
-      "size_bytes": 4423
+      "sha256": "sha256:64874764924929421c294e7a421d546aba245d8f8bc40caba32d889f557c1906",
+      "size_bytes": 4850
     },
     {
       "path": "skills/feature-management/references/supervised-datasets.md",
-      "sha256": "sha256:2c23ed96c49af1954864660bf8d13f3114bb03a6598e20df6abbc191c5986e2b",
-      "size_bytes": 10024
+      "sha256": "sha256:a12ef5c26bc206507679e60fbecfa8bc1f5cfeb357e428b9dc8d1cdac6458a8a",
+      "size_bytes": 10886
     },
     {
       "path": "skills/model-deployment-management/SKILL.md",
-      "sha256": "sha256:84c58dbc71046ead45e3bd1aea55a5f98908e633314dbd088ce6d2c83987011c",
-      "size_bytes": 5195
+      "sha256": "sha256:5e1f92a03584df4631e896754b9b91012678b2358c1df7df55aa610fd527bf1d",
+      "size_bytes": 5505
     },
     {
       "path": "skills/model-deployment-management/agents/openai.yaml",
@@ -142,28 +152,33 @@
     },
     {
       "path": "skills/model-deployment-management/references/contracts.md",
-      "sha256": "sha256:967d70e1d162ce0f8736683fd82009c7aa4227a309f38de14199469bb3bfe52c",
-      "size_bytes": 6722
+      "sha256": "sha256:10a86a5f0ba36546c8487ea0bf78366f9034c9f713b80bb76a4fdb39aed67957",
+      "size_bytes": 7178
     },
     {
       "path": "skills/model-deployment-management/references/operations.md",
-      "sha256": "sha256:262ac8d3ab7524a9b30a14a95550a28821626a8832fd967fe3e9acd015f8c7b2",
-      "size_bytes": 6987
+      "sha256": "sha256:ee98dbd02d84318108c157913e19353d1a6931cbe647af4125cffecbca155fea",
+      "size_bytes": 7854
     },
     {
       "path": "skills/model-deployment-management/references/troubleshooting.md",
-      "sha256": "sha256:a1eb8f9419f9b05ccc92344f9050c4dfa91635284e3a19139afe2127706fa40f",
-      "size_bytes": 3771
+      "sha256": "sha256:1d727c2e76fdbe361bdd5199bc63377feea9564b6b4d41842250bce1f23447f5",
+      "size_bytes": 4331
     },
     {
       "path": "skills/model-lifecycle-management/SKILL.md",
-      "sha256": "sha256:55f0172c0b79a04b8ddfeb6bb9f617e7cb5da622b6bd43b3dbae2d3318f6f877",
-      "size_bytes": 7447
+      "sha256": "sha256:099973e2dd334beac12e275ee184d3ce500f6c307ae339e3400e585d8ad88a8e",
+      "size_bytes": 7833
     },
     {
       "path": "skills/model-lifecycle-management/agents/openai.yaml",
-      "sha256": "sha256:37857849a8baa6b06b6d5d07ae6036080239356fcccd36f77bbdc52c1dfa283f",
-      "size_bytes": 249
+      "sha256": "sha256:096bb0bca665622326b214a4d88d5b6807b50cf143b8a2e05528256fc3568f58",
+      "size_bytes": 258
+    },
+    {
+      "path": "skills/model-lifecycle-management/references/ablation.md",
+      "sha256": "sha256:41182c0c356626b04387c4b613cf293528187a98bc7d05b12f3d379ac51ad0ab",
+      "size_bytes": 5581
     },
     {
       "path": "skills/model-lifecycle-management/references/discovery.md",
@@ -172,13 +187,18 @@
     },
     {
       "path": "skills/model-lifecycle-management/references/evaluation.md",
-      "sha256": "sha256:ba16117c0bf37ac92e28dc9b5e3bda266ac6ad29993c3d4bfcc1c955bb0ab3fa",
-      "size_bytes": 16573
+      "sha256": "sha256:124c938f8ab633d6851357add501dd8e5defdfa2c81e8305b045f93656e6236e",
+      "size_bytes": 18889
+    },
+    {
+      "path": "skills/model-lifecycle-management/references/experiment-runs.md",
+      "sha256": "sha256:43360b72f2f9565640241450be01d95b44ebd5750d13c0ea9af47158bda35ccc",
+      "size_bytes": 2719
     },
     {
       "path": "skills/model-lifecycle-management/references/model-comparison.md",
-      "sha256": "sha256:cb97b16476e28d3ca6f984ef2a964f936227bbb28a11570bbcd86f6ea51bccba",
-      "size_bytes": 9359
+      "sha256": "sha256:13eeb1226effffc4eee1cacdb4ea04f4f61bc31874190046b6634e8e7bb49703",
+      "size_bytes": 9391
     },
     {
       "path": "skills/model-lifecycle-management/references/packaging.md",
@@ -192,8 +212,8 @@
     },
     {
       "path": "skills/model-lifecycle-management/references/training.md",
-      "sha256": "sha256:654d3d45bfae4906f7f37898d09fa1fa84ecaab46346190c439f9f3fc0e17f95",
-      "size_bytes": 9691
+      "sha256": "sha256:3ebf309ff7ede6b38dcb5b9afd75d282d29e91d768b9926808687c58434f88c9",
+      "size_bytes": 11419
     },
     {
       "path": "skills/model-lifecycle-management/references/zero-shot-inference.md",
@@ -202,8 +222,8 @@
     },
     {
       "path": "skills/prediction-report-management/SKILL.md",
-      "sha256": "sha256:fb1f8c579d392cc4d030d41b5c3b06cd59ab0c488de343bae93cbc87a27dd650",
-      "size_bytes": 8707
+      "sha256": "sha256:e7ad90295929b01dc6640a6a5fe42b0dcbfd56c52fb329a05875bf1a706e7874",
+      "size_bytes": 8894
     },
     {
       "path": "skills/prediction-report-management/agents/openai.yaml",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhuoyuezs/ml-platform",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "ML 数据平台 business CLI 与 Agent Skills 管理工具",
   "bin": {
     "ml-platform": "scripts/main.js"

package/release.json

@@ -13,7 +13,7 @@
     "entrypoint": "src/cli.js",
     "name": "ml-platform",
     "path": "runtime/business-client",
-    "sha256": "sha256:6b8adc18d15ead31da78bd6e4274d17bb7277edcb0d76a9b476ae77a3be22812",
+    "sha256": "sha256:5b83423598eb2c8afae8765e4315a9432cc026d1779348808c6516432820e67e",
     "version": "0.8.7"
   },
   "policy_sha256": "sha256:02fbde0134696b78c0c365d6e0b76c9814227208da5b2b3d4e5dbd82dc4a3606",
@@ -25,7 +25,7 @@
     "ml_data_platform.feature_set/v1",
     "ml_data_platform.dataset_manifest/v1"
   ],
-  "release_version": "0.2.9",
+  "release_version": "0.2.10",
   "runtime_requirements": {
     "node": ">=18",
     "os": [
@@ -38,33 +38,33 @@
     "data-source-exploration": {
       "path": "skills/data-source-exploration",
       "requires_cli": ">=0.8.7 <0.9.0",
-      "revision": "0.2.9",
-      "sha256": "sha256:6cb1cad3e9531e5098582c532288edd9838c2acab2b324794ec99d2550418f32"
+      "revision": "0.2.10",
+      "sha256": "sha256:9614e6901fcfeac7e0779caee7a8ab1df40b39d08161967e51b459c266b82f90"
     },
     "feature-management": {
       "path": "skills/feature-management",
       "requires_cli": ">=0.8.7 <0.9.0",
-      "revision": "0.2.9",
-      "sha256": "sha256:2bd8e19ffe43e414fe74a269a75ccfdb88e66c7f2a52df6230a929321dbb54ea"
+      "revision": "0.2.10",
+      "sha256": "sha256:c2f109d11ddfdfe9deaa2da077cd11f374bc8cef0db6155572fbb24defab39f7"
     },
     "model-deployment-management": {
       "path": "skills/model-deployment-management",
       "requires_cli": ">=0.8.7 <0.9.0",
-      "revision": "0.2.9",
-      "sha256": "sha256:26cbe95ca26371f3b34a4b83a1f185eeb879f64f099d9dbc30e4cc4ec81d9c64"
+      "revision": "0.2.10",
+      "sha256": "sha256:ef13c737a098e9a582dfa6f7c54777c00a9efbc7af894c7aea35b9db4a97aa15"
     },
     "model-lifecycle-management": {
       "path": "skills/model-lifecycle-management",
       "requires_cli": ">=0.8.7 <0.9.0",
-      "revision": "0.2.9",
-      "sha256": "sha256:40d8b5eef72a937c208c3607b41666015ac143f604fb0521e0953659306182b2"
+      "revision": "0.2.10",
+      "sha256": "sha256:02fc9451ae888bec7ae1aa38bf51c3c8f657c6f899506ce323f17552b2dd31a0"
     },
     "prediction-report-management": {
       "path": "skills/prediction-report-management",
       "requires_cli": ">=0.8.7 <0.9.0",
-      "revision": "0.2.9",
-      "sha256": "sha256:0aee744970236f0357aa9e264e31e144b3cb6fab4a3ea6a01f184dcdaef7e846"
+      "revision": "0.2.10",
+      "sha256": "sha256:399e5838604b5ce0248be702b70be2deaaf8f644e5518c91c45d21e0d2f43e53"
     }
   },
-  "source_commit": "e0c33cf9f1d052d2a24a574393fdf804438a4543"
+  "source_commit": "b9b4ec03474a9ff7b11bae35eacf8302bcb97d0c"
 }

package/runtime/business-client/src/cli.js

@@ -7,7 +7,7 @@ const { configPath, expandHome, loadApiUrl, normalizeApiUrl, saveApiUrl } = requ
 const { PlatformApiClient } = require("./http");
 const { applyCatalog, loadCatalog, normalizeDataset, normalizeRegistryDataset } = require("./catalog");
 const { version: CLIENT_VERSION } = require("../package.json");
-const LIFECYCLE_COLLECTIONS = new Set(["training-runs", "training-jobs", "model-artifacts", "evaluation-configs", "evaluation-runs", "evaluation-jobs", "metric-definitions", "executable-packages", "model-packages"]);
+const LIFECYCLE_COLLECTIONS = new Set(["training-runs", "training-jobs", "model-artifacts", "evaluation-configs", "evaluation-runs", "evaluation-jobs", "metric-definitions", "executable-packages", "model-packages", "experiment-runs"]);
 const BUSINESS_COMMANDS = new Set([
     ...[...LIFECYCLE_COLLECTIONS].map((name) => `list-${name}`),
     "get-model-runtime-release", "get-training-run", "get-model-artifact", "get-executable-package",
@@ -15,6 +15,9 @@ const BUSINESS_COMMANDS = new Set([
     "version", "create-project", "list-projects", "get-project", "delete-project",
     "get-dataset-contract-file", "validate-evaluation-comparison",
     "configure", "show-config", "health",
+    "data-platform-status", "list-data-platform-connections", "get-data-platform-connection",
+    "list-data-platform-objects", "list-data-platform-mappings", "list-data-platform-query-candidates", "get-data-platform-mapping-revision",
+    "bind-data-platform-parameters", "query-data-platform", "get-data-platform-query", "get-data-platform-snapshot",
     "list-datasource-connections", "list-datasource-namespaces", "list-datasource-objects",
     "list-datasource-fields", "query-datasource-object", "create-datasource-connection",
     "get-datasource-connection", "update-datasource-connection", "delete-datasource-connection",
@@ -34,6 +37,7 @@ const BUSINESS_COMMANDS = new Set([
     "get-job", "wait-job", "retry-job", "cancel-job", "get-dataset-artifact", "download-dataset-artifact", "fetch-inference-data", "fetch-inference-context", "predict-model", "apply",
     "list-foundation-models", "get-foundation-model", "predict-foundation", "predict-foundation-csv",
     "list-system-models", "get-system-model", "register-training-run", "validate-training-run", "submit-training-job", "get-training-job", "retry-training-job", "cancel-training-job",
+    "create-experiment-run", "validate-experiment-run", "submit-experiment-run", "get-experiment-run", "list-experiment-candidates", "reconcile-experiment-run", "cancel-experiment-run",
     "register-evaluation-config", "get-evaluation-config", "register-metric-definition", "get-metric-definition",
     "register-executable-package", "verify-executable-package", "publish-executable-package",
     "validate-evaluation-run", "submit-evaluation", "get-evaluation-run", "get-evaluation-job", "retry-evaluation-job", "cancel-evaluation-job", "list-evaluation-attempts",
@@ -62,6 +66,17 @@ const COMMAND_USAGE = {
     configure: "configure --api-url URL",
     "show-config": "show-config",
     health: "health",
+    "data-platform-status": "data-platform-status",
+    "list-data-platform-connections": "list-data-platform-connections",
+    "get-data-platform-connection": "get-data-platform-connection CONNECTION_ID",
+    "list-data-platform-objects": "list-data-platform-objects CONNECTION_ID",
+    "list-data-platform-mappings": "list-data-platform-mappings [--page N] [--page-size N] [--scope-code CODE]",
+    "list-data-platform-query-candidates": "list-data-platform-query-candidates",
+    "get-data-platform-mapping-revision": "get-data-platform-mapping-revision MAPPING_ID REVISION_ID",
+    "bind-data-platform-parameters": "bind-data-platform-parameters SPEC_JSON",
+    "query-data-platform": "query-data-platform SPEC_JSON",
+    "get-data-platform-query": "get-data-platform-query RUN_ID",
+    "get-data-platform-snapshot": "get-data-platform-snapshot SNAPSHOT_ID [--offset N] [--limit N]",
     "list-datasource-connections": "list-datasource-connections [--limit N] [--cursor CURSOR]",
     "list-datasource-namespaces": "list-datasource-namespaces CONNECTION_ID [--limit N] [--cursor CURSOR]",
     "list-datasource-objects": "list-datasource-objects CONNECTION_ID NAMESPACE_ID [--limit N] [--cursor CURSOR]",
@@ -168,6 +183,13 @@ const COMMAND_USAGE = {
     "create-model-package": "create-model-package REQUEST_JSON [--idempotency-key KEY]",
     "get-model-package": "get-model-package PACKAGE_ID [--package-version VERSION]",
     "cancel-model-package": "cancel-model-package PACKAGE_ID [--package-version VERSION]",
+    "create-experiment-run": "create-experiment-run SPEC_JSON",
+    "validate-experiment-run": "validate-experiment-run RUN_ID",
+    "submit-experiment-run": "submit-experiment-run RUN_ID",
+    "get-experiment-run": "get-experiment-run RUN_ID",
+    "list-experiment-candidates": "list-experiment-candidates RUN_ID [--limit N] [--offset N]",
+    "reconcile-experiment-run": "reconcile-experiment-run RUN_ID",
+    "cancel-experiment-run": "cancel-experiment-run RUN_ID",
     "validate-model-artifact": "validate-model-artifact ARTIFACT_ID",
     "register-model-artifact": "register-model-artifact ARTIFACT_ID --evaluation-id EVALUATION_ID",
     "list-business-domains": "list-business-domains",
@@ -490,6 +512,42 @@ async function runBusinessCli(argv, output = { write: text => process.stdout.wri
     }
     else if (options.command === "health")
         result = await client(options).get("/health");
+    else if (options.command === "data-platform-status")
+        result = await client(options).get("/data-platform/status");
+    else if (options.command === "list-data-platform-connections")
+        result = await client(options).get("/data-platform/connections");
+    else if (options.command === "list-data-platform-query-candidates")
+        result = await client(options).get("/data-platform/query-candidates");
+    else if (["get-data-platform-connection", "list-data-platform-objects"].includes(options.command)) {
+        const id = encodeURIComponent(positional(rest, "connection id"));
+        const suffix = options.command === "list-data-platform-objects" ? "/objects" : "";
+        result = await client(options).get(`/data-platform/connections/${id}${suffix}`);
+    }
+    else if (options.command === "list-data-platform-mappings") {
+        result = await client(options).get("/data-platform/mappings", {
+            page: integer(take(rest, "--page", "1"), "page"),
+            page_size: integer(take(rest, "--page-size", "50"), "page size"),
+            scope_code: take(rest, "--scope-code"),
+        });
+    }
+    else if (options.command === "get-data-platform-mapping-revision") {
+        const mappingId = encodeURIComponent(positional(rest, "mapping id"));
+        const revisionId = encodeURIComponent(positional(rest, "revision id"));
+        result = await client(options).get(`/data-platform/mappings/${mappingId}/revisions/${revisionId}`);
+    }
+    else if (options.command === "bind-data-platform-parameters")
+        result = await client(options).post("/data-platform/parameters", readSpec(positional(rest, "binding spec JSON")));
+    else if (options.command === "query-data-platform")
+        result = await client(options).post("/data-platform/query-runs", readSpec(positional(rest, "query spec JSON")));
+    else if (options.command === "get-data-platform-query")
+        result = await client(options).get(`/data-platform/query-runs/${encodeURIComponent(positional(rest, "run id"))}`);
+    else if (options.command === "get-data-platform-snapshot") {
+        const id = encodeURIComponent(positional(rest, "snapshot id"));
+        result = await client(options).get(`/data-platform/snapshots/${id}/rows`, {
+            offset: integer(take(rest, "--offset", "0"), "offset"),
+            limit: integer(take(rest, "--limit", "200"), "limit"),
+        });
+    }
     else if (options.command === "list-datasource-connections") {
         result = await client(options).get("/datasource-connections", datasourcePageParams(rest));
     }
@@ -1051,6 +1109,34 @@ async function runBusinessCli(argv, output = { write: text => process.stdout.wri
     else if (options.command === "get-model-runtime-release") {
         result = await client(options).get("/model-runtime-release");
     }
+    else if (options.command === "create-experiment-run") {
+        result = await client(options).post("/experiment-runs", readSpec(positional(rest, "experiment JSON")));
+    }
+    else if (/^(validate|submit|reconcile|cancel)-experiment-run$/.test(options.command)) {
+        const runId = positional(rest, "experiment run id");
+        const action = options.command.split("-")[0];
+        result = await client(options).post(`/experiment-runs/${encodeURIComponent(runId)}/${action}`);
+    }
+    else if (options.command === "get-experiment-run") {
+        result = await client(options).get(`/experiment-runs/${encodeURIComponent(positional(rest, "experiment run id"))}`);
+    }
+    else if (options.command === "list-experiment-candidates") {
+        const runId = positional(rest, "experiment run id");
+        const params = {};
+        const limit = take(rest, "--limit");
+        const offset = take(rest, "--offset");
+        if (limit !== undefined) {
+            params.limit = integer(limit, "--limit");
+            if (params.limit < 1 || params.limit > 500)
+                throw new Error("--limit must be between 1 and 500");
+        }
+        if (offset !== undefined) {
+            params.offset = integer(offset, "--offset");
+            if (params.offset < 0)
+                throw new Error("--offset must be non-negative");
+        }
+        result = await client(options).get(`/experiment-runs/${encodeURIComponent(runId)}/candidates`, params);
+    }
     else if (options.command.startsWith("list-") && LIFECYCLE_COLLECTIONS.has(options.command.slice(5))) {
         const params = {};
         const limit = take(rest, "--limit");

package/skills/data-source-exploration/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: data-source-exploration
-description: Discover platform-configured PostgreSQL, MySQL, SQL Server, or InfluxDB objects and run bounded structured reads for local data and feature exploration. Use when an algorithm engineer wants to inspect visible databases, schemas, tables, measurements, fields, or limited rows before defining governed feature assets. Do not use for free-form SQL, bulk export, asset publication, dataset builds, or model training.
+description: Discover platform-configured database objects or published external data-platform Mappings, and run bounded structured or Mapping snapshot reads for local data and feature exploration. Use when an algorithm engineer wants to inspect visible sources, Mapping outputs, time coverage or limited rows before defining governed feature assets. Do not use for free-form SQL, bulk export, asset publication, dataset builds, or model training.
 ---
 
 # Data Source Exploration
@@ -10,6 +10,15 @@ never request credentials in chat. The platform exposes managed connections and
 objects. Connection credentials are write-only control-plane input and are never returned by the
 platform.
 
+## External Data Platform
+
+For external published mapping discovery and bounded query/snapshot reads, follow
+[the external data platform reference](references/data-platform.md). This includes the complete
+authorized query-candidate catalog, fixed Mapping revisions, asynchronous query runs and paged
+snapshots. Keep that catalog separate from the direct database connections below; it has its own
+IDs, permissions and query semantics. Use `$feature-management` to bind confirmed outputs to
+Parameters and build features; discovery alone does not publish assets.
+
 ## Manage Connections
 
 Datasource connections are business-owned platform resources, not ConfigMap entries. An operator
@@ -48,6 +57,8 @@ Before discovery, verify the installed client and server target:
 
 ```bash
 command -v ml-platform
+ml-platform version
+ml-platform show-config
 ml-platform health
 ```
 

package/skills/data-source-exploration/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "数据源与特征探索"
-  short_description: "逐层发现已连接数据源并执行受限数据查询"
-  default_prompt: "使用 $data-source-exploration 从平台已连接数据源中发现可见库表字段，执行有限查询，并整理数据与特征假设。"
+  short_description: "发现已连接数据源或外部 Mapping，并执行有界查询"
+  default_prompt: "使用 $data-source-exploration 发现平台可见库表字段或外部数据平台已发布 Mapping，执行有界查询和快照读取，并整理覆盖率、数据与特征假设。"

package/skills/data-source-exploration/references/data-platform.md

@@ -0,0 +1,83 @@
+# Read Published Mappings From The External Data Platform
+
+Use this path when the user requests data owned by the external data platform. The modeling
+server holds its login configuration; agents never need its credentials or database DSNs.
+Discover available options with the installed `ml-platform --help`; an older CLI or unconfigured
+server does not imply permission to fall back to a physical database.
+
+1. Run `ml-platform data-platform-status` and `ml-platform list-data-platform-connections`.
+2. Inspect connection metadata and objects with `get-data-platform-connection ID` and
+   `list-data-platform-objects ID`. These are catalogs, not a physical-query interface.
+3. Prefer `list-data-platform-query-candidates` for model data discovery. It requires the
+   integration account's upstream `query:run` capability and returns its complete authorized,
+   published, enabled and ready catalog as `candidates`, `complete: true`, and `total`, without
+   reading source data. Inspect business names, domains and output labels, keys, units, roles and
+   types; filter this complete set locally. It accepts no paging or filter flags. An empty complete
+   set is an honest empty result; domains are presentation metadata, not permission grants.
+   For an older upstream that lacks this endpoint, use
+   `list-data-platform-mappings --page 1 --page-size 50 [--scope-code CODE]`, follow every page
+   using `total`, and inspect `lifecycle.run_readiness`. This catalog alone does not prove query
+   authorization. Do not fall back on a permission error or to bypass blocked mappings.
+4. Inspect `get-data-platform-mapping-revision MAPPING_ID REVISION_ID`. Confirm output keys,
+   units and time semantics. Preserve `active_revision.mapping_revision_id` for reproducibility.
+   Execution rechecks authorization and revision state; discovery does not reserve access.
+5. Write a bounded query JSON in the user's workspace, outside the platform repository:
+
+   ```json
+   {
+     "mapping": {"mapping_revision_id": "33333333-3333-4333-8333-333333333333"},
+     "window_start": "2026-10-01T00:00:00+08:00",
+     "window_end": "2026-10-01T01:00:00+08:00",
+     "max_rows": 100,
+     "execution": "async"
+   }
+   ```
+
+6. Submit with `ml-platform query-data-platform query.json`. For async submission, poll
+   `get-data-platform-query RUN_ID` until terminal. Read `result.snapshot_id` on success;
+   a successful HTTP poll alone does not establish successful execution.
+7. Read `get-data-platform-snapshot SNAPSHOT_ID --offset 0 --limit 100`. Advance offset by the
+   returned row count until it reaches `captured_rows`. An empty page before that count is an
+   incomplete read, not successful completion. Record run ID,
+   snapshot ID, mapping revision, columns and their order,
+   window, warnings and `completeness`. Partial or truncated results cannot establish complete
+   coverage. An empty result is not evidence that the source has no data outside this window.
+
+Do not resubmit uncertain POSTs automatically. Keep the returned run ID; after a timeout or
+connection failure, inspect actual task state in the data platform before another submission.
+For `SOURCE_SCHEMA_DRIFT`, ask the data owner to repair/revalidate the source mapping; never
+bypass that gate with a physical ReadSpec or SQL.
+
+For training or realtime inference, hand off confirmed outputs to `$feature-management` and its
+Mapping binding workflow. `bind-data-platform-parameters SPEC_JSON` creates/reuses ordinary immutable
+Parameters; exploration alone does not authorize that write. The adapter accepts single published
+structured, unaggregated series, or SQL ReadSpecs, with no inputs/expressions composition. SQL remains
+executed upstream. Mapping output contracts, coverage and causal semantics still require validation;
+SQL-derived values do not prove historical visibility. Duplicate event times and partial snapshots fail.
+
+Use the facade query commands for discovery and inspection. Use the Parameter adapter for dataset
+builds and realtime reads; do not copy snapshot rows into catalogs or commit credentials.
+
+## Coverage, Visibility And Failure Evidence
+
+Start with a short business-relevant window, then expand within the approved query scope when
+checking history coverage. The query facade accepts `max_rows` up to 10000 and snapshot pages up
+to 1000 rows. If a result is partial or truncated, split the time window rather than using the
+captured subset as a complete dataset. Keep the same fixed revision and inspect every window's
+warnings: source SQL may impose its own historical limit even when the snapshot is marked complete.
+Check the requested time grid, first/last timestamps, missingness, duplicates and values; a small
+successful sample does not prove the larger training window is usable.
+
+Query/read timestamps describe when data was retrieved. They do not establish when each source row
+first became available. Record whether the Mapping actually publishes a trustworthy availability
+field, and hand this evidence to `$feature-management`; do not invent it from event time or query
+completion time. Ordinary snapshot exploration can proceed without such a field, while strict
+historical `as_of` correctness remains unproven.
+
+Distinguish release/configuration failures from empty data. A missing CLI command requires checking
+the installed release; a missing route requires checking the deployed API. A `503` with
+`DATA_PLATFORM_NOT_CONFIGURED` means the server lacks integration configuration. Permission or
+schema-drift failures need resolution in the upstream account/Mapping. Timeouts and disconnected
+POSTs leave submission uncertain; inspect run state before retrying. API health alone does not prove
+upstream authentication or dataset-build Worker support. Report the failed checkpoint and target
+without exposing passwords, cookies, CSRF tokens or Secret contents.

package/skills/feature-management/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: feature-management
-description: Manage projects, versioned business feature assets and their lifecycle, dataset rowsets and endpoint eligibility, and causal realtime row or sequence-context 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, inspect references, soft-delete or restore a Parameter/Feature/FeatureSet version, configure training/validation/test rowsets or abnormal-data endpoint exclusion, configure realtime freshness policy, run catalog dry-run/apply, build a dataset, fetch inference data, or inspect an artifact without downloading the platform source repository. Do not use for model training, Operator/Dataset deletion, image builds, or Kubernetes deployment.
+description: Manage projects, versioned business feature assets and their lifecycle, dataset rowsets and endpoint eligibility, and causal realtime row or sequence-context 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, bind published external data-platform Mapping outputs to Parameters, author/package/register an Operator wheel, define single-column Features, order a FeatureSet, create a DatasetManifest or catalog, inspect references, soft-delete or restore a Parameter/Feature/FeatureSet version, configure training/validation/test rowsets or abnormal-data endpoint exclusion, configure realtime freshness policy, run catalog dry-run/apply, build a dataset, fetch inference data, or inspect an artifact without downloading the platform source repository. Do not use for model training, Operator/Dataset deletion, image builds, or Kubernetes deployment.
 ---
 
 # Feature Management
@@ -52,7 +52,8 @@ Keep these evidence rules active in every workflow:
 4. Read [references/operator-authoring.md](references/operator-authoring.md) whenever creating or changing Operator code or a wheel.
 5. Read [references/commands.md](references/commands.md) immediately before a platform CLI action: discovery, validation, publication, build, realtime fetch, or artifact download. A local-only draft that is forbidden to call the CLI does not need this reference.
 6. 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.
-7. Read [references/platform-capability-guide.md](references/platform-capability-guide.md) only when selecting an asset type or explaining a platform capability. Do not load it merely to write a confirmed local draft; it is never evidence for unresolved business semantics.
+7. Read [references/data-platform-mapping.md](references/data-platform-mapping.md) when binding published external data-platform Mapping outputs to Parameters.
+8. Read [references/platform-capability-guide.md](references/platform-capability-guide.md) only when selecting an asset type or explaining a platform capability. Do not load it merely to write a confirmed local draft; it is never evidence for unresolved business semantics.
 
 ## Initialize The Client
 
@@ -110,7 +111,8 @@ Confirm:
 - the target project (namespace) for the assets; use the built-in `default` only when the user has no dedicated project. After the target is confirmed, write its explicit `project` field in every Parameter, Operator, Feature, FeatureSet and DatasetManifest draft; never rely on the schema default. Reads and filters use the `--project` command option;
 - business meaning, stable asset names, owner, and intended consumers;
 - Parameter source adapter (`postgresql_direct`, `mysql_direct`,
-  `sqlserver_direct`, or `influxdb_direct`) and credential-free source mapping;
+  `sqlserver_direct`, `influxdb_direct`, or `data_platform_mapping`) and credential-free
+  source mapping; for external Mappings, confirm the published revision and output keys;
 - 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;
@@ -264,7 +266,13 @@ unit, time/availability semantics and missing policy in the semantic review.
 Never infer a source table, column, measurement, tag, unit or timezone from a
 Parameter name.
 
-Create one stable, versioned source contract for each independently readable value. Keep credentials out of JSON. Use only supported direct adapters (`postgresql_direct`, `mysql_direct`, `sqlserver_direct`, and `influxdb_direct`) and explicit source identity. For PostgreSQL, keep `source.adapter=postgresql_direct` and put the configured alias in `source.connection_id` (for example `postgresql_bf_monitoring`); never put the connection alias in `source.adapter`. The server supplies database DSNs from managed Secrets; never add them to CLI arguments or Catalog JSON. A missing `connection_id` on a historical PostgreSQL Parameter uses the compatibility default `postgresql`. Put source data validity in `quality_rules`; put dataset-specific transformations in preprocess Operators.
+Create one stable, versioned source contract for each independently readable value. Keep credentials out of JSON. Direct database sources use `postgresql_direct`, `mysql_direct`, `sqlserver_direct`, or `influxdb_direct` and explicit source identity. For PostgreSQL, keep `source.adapter=postgresql_direct` and put the configured alias in `source.connection_id` (for example `postgresql_bf_monitoring`); never put the connection alias in `source.adapter`. The server supplies database DSNs from managed Secrets; never add them to CLI arguments or Catalog JSON. A missing `connection_id` on a historical PostgreSQL Parameter uses the compatibility default `postgresql`. Put source data validity in `quality_rules`; put dataset-specific transformations in preprocess Operators.
+
+For an approved external Mapping, use `bind-data-platform-parameters` to create or reuse
+`data_platform_mapping` Parameters and retain the returned Feature input references. Follow
+[the Mapping reference](references/data-platform-mapping.md) for revision pinning, visibility,
+read budgets and Worker acceptance. The Mapping owns its database connection and SQL; do not
+copy them into the Parameter or add a second public binding resource.
 
 When historical and live systems expose the same value, keep one Parameter and add an optional
 `online_source`. Batch/as-of reads always use `source`; realtime causal reads use `online_source`

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

@@ -1,4 +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."
+  short_description: "绑定外部 Mapping，管理特征、数据集与实时推理取数"
+  default_prompt: "Use $feature-management to bind published external Mapping outputs to Parameters, manage versioned feature assets, build datasets, or fetch causal realtime inference data through the platform API."

package/skills/feature-management/references/commands.md

@@ -436,3 +436,17 @@ Use a structured Parquet reader for schema, row count, column order, and missing
 - Do not claim a successful publication from `--dry-run` output.
 - Do not claim Chronon compile/backfill from a successful first-phase Operator build.
 - Do not use `build-dataset` to serve a single realtime inference cutoff.
+
+## Bind Published Data Platform Outputs
+
+When source semantics and publication are confirmed, use the existing external Mapping directly.
+This creates ordinary immutable Parameters; it does not publish Mapping assets or execute a dataset
+build:
+
+```bash
+ml-platform bind-data-platform-parameters --help
+ml-platform bind-data-platform-parameters binding.json
+```
+
+See [data-platform-mapping.md](data-platform-mapping.md) for the request, returned Feature input
+references, visibility requirements, Worker requirements and acceptance checks.

package/skills/feature-management/references/data-platform-mapping.md

@@ -0,0 +1,104 @@
+# Bind And Build From External Data Platform Mappings
+
+Use after the user has authorized publishing confirmed source contracts. Discovery remains in
+`data-source-exploration`; this workflow writes existing Parameter resources through the modeling API.
+Verify the installed CLI and configured API using the main Skill, then inspect command help.
+
+1. Discover a ready published Mapping with `list-data-platform-query-candidates`, then inspect
+   its pinned `active_revision.mapping_revision_id` with
+   `get-data-platform-mapping-revision ID REVISION`. Discovery returns the complete catalog
+   authorized for the integration account; it does not prove data coverage or reserve query access.
+   For older upstreams, follow the discovery reference's paged Mapping workflow.
+2. Confirm numeric value output keys, the unique event-time output, units, source timezone,
+   frequency, precision, entity scope and historical coverage. Do not treat Mapping readiness or a
+   complete snapshot as proof of causal correctness. SQL may already compute values or limit history.
+3. Write a binding JSON outside the platform repository:
+
+   ```json
+   {
+     "project": "default",
+     "mapping_id": "11111111-1111-4111-8111-111111111111",
+     "mapping_revision_id": "22222222-2222-4222-8222-222222222222",
+     "output_keys": ["out_value"],
+     "expected_frequency": "10min",
+     "event_time_precision": "s"
+   }
+   ```
+
+   Substitute confirmed IDs and settings. `output_keys` contains value outputs only. Source timezone
+   comes from the ReadSpec; if missing, supply `time_semantics`. Optional `time_semantics`,
+   `quality_rules`, `owner`, `partition_seconds`, `max_rows`, `timeout_seconds` follow the existing
+   contracts. Never infer availability from request time. Strict `as_of` requires the Mapping to
+   expose the trustworthy availability field declared in `time_semantics.availability`.
+4. Run `ml-platform bind-data-platform-parameters binding.json`. Preserve each returned `reference`
+   as a Feature input (`project`, `parameter`, `version`). The response also contains the full
+   Parameter. Do not manually recreate its source, SQL, credentials or version.
+5. Continue normal Operator → Feature → FeatureSet → DatasetManifest publication. Operator history
+   requirements govern source lookback; binding does not add a shared fixed window. Build and realtime
+   reads use `source_mode=direct`.
+6. For a DatasetManifest build, distinguish CLI submission from Worker execution. Inspect `get-job`
+   until a terminal status, then retrieve the DatasetArtifact. Confirm row and column counts against
+   the requested grid, Parquet column order, missing values, time coverage, and source-read evidence
+   (`mapping_revision_id`, `run_id`, `snapshot_id`, plan/window and actual read times) before handing
+   the dataset to model training. A submitted or running Kubernetes Job is not build evidence.
+
+Repeated identical binding requests reuse deterministic Parameter identities. Changed Mapping revision
+or effective configuration creates a new immutable version. Existing manually named Parameters are not
+searched or merged. Multiple outputs are validated before writing, but each Parameter persists
+independently; there is no cross-resource transaction. After an uncertain response, repeating the same
+binding safely converges to the same Parameter contents. This does not mean uncertain upstream query
+POSTs may be retried: inspect those runs separately.
+
+Supported sources are single structured, unaggregated series, or SQL ReadSpecs without composed
+inputs/expressions. SQL executes in the data platform. Ambiguous duplicate event times, partial snapshots and
+revision/window mismatches fail. The adapter preserves source warnings, run, snapshot, Mapping
+revision, plan, window and actual read times. Fixed definitions do not freeze mutable upstream rows
+or make expiring snapshots permanent.
+
+`read_started_at`/`read_finished_at` record when the adapter performed this read. They are audit
+metadata, not per-row source availability evidence. A Mapping without a trustworthy published
+availability output can be used for ordinary snapshot reads, but it cannot establish strict
+historical `as_of` visibility. Do not substitute request/read time, event time, or `ingested_at`
+for `available_at` unless the Parameter contract explicitly identifies that source field as the
+trusted availability boundary. A complete snapshot proves transfer completeness, not historical
+visibility or business coverage.
+
+Mapping reads bypass ITSMP source cache so each read retains its upstream snapshot lineage.
+`partition_seconds` defaults to 86400 (range 1–86400); each partition's `max_rows` defaults to and
+cannot exceed 10000. One source read accepts at most 1024 partitions. `timeout_seconds` defaults
+to 180 and accepts at most 600; it is checked between HTTP calls, whose own client timeout also
+applies. These are source-adapter budgets, separate from Dataset build execution partitions.
+If coverage exceeds a budget, choose a justified source partition or build window; never accept
+truncation or remove required Operator history to make a read succeed. The adapter converts
+upstream half-open windows into the closed source observation boundary, including its end instant;
+the Dataset target grid remains half-open.
+
+## Worker Runtime Requirements And Failures
+
+The business CLI does not configure Kubernetes, publish images or mount credentials. The platform
+operator must configure the modeling API with the upstream integration Secret and configure the
+dataset-build Job template to mount that Secret read-only and set
+`DATA_PLATFORM_UPSTREAM_CONFIG_FILE`. Build Workers must receive the updated dataset-build image
+containing the `data_platform_mapping` source adapter; changing only the API image is insufficient.
+The API and Worker must use compatible platform code, but training and serving images do not need
+this data-source adapter unless they themselves read Mapping data.
+
+After catalog publication and build submission:
+
+- On terminal success, inspect and download the artifact before reporting data success.
+- If the job is accepted but remains queued, check Worker scheduling, quotas and active Jobs with
+  the platform operator; do not resubmit while its durable state is uncertain.
+- If the Worker reports `unsupported source adapter` for `data_platform_mapping`, verify the
+  deployed dataset-build image includes the adapter. A healthy API or successful catalog `apply`
+  does not prove the Worker image was updated.
+- If the Worker cannot load `DATA_PLATFORM_UPSTREAM_CONFIG_FILE`, or upstream authentication/network
+  fails, have the platform operator verify the Secret key/path, read-only mount, Worker namespace,
+  egress and integration-account permissions. Never copy credentials into the Parameter, Manifest,
+  CLI arguments or logs.
+- For an uncertain query POST, inspect the upstream run before retrying. For a failed build, inspect
+  the durable Job and Worker logs, correct the identified cause, and submit a new attempt only after
+  confirming the previous attempt is terminal; do not blindly repeat the same request.
+
+The Skill can guide asset authoring and API/CLI evidence collection, but it cannot diagnose container
+exit causes from `get-job` alone or safely change the cluster. Keep Kubernetes events, pod reason,
+container exit code and log tail as separate operational evidence.

package/skills/feature-management/references/platform-capability-guide.md

@@ -14,6 +14,12 @@ replay metadata, and data Job execution. This Skill covers that data subsystem;
 use the separate model lifecycle Skill for training, evaluation and packaging.
 Model serving, source-table creation and Kubernetes administration are outside
 this Skill's scope. Do not present a Skill boundary as a platform capability gap.
+Parameters may read through the platform's direct database adapters or a pinned,
+published external data-platform Mapping. Mapping discovery and source query
+semantics remain owned by `$data-source-exploration`; binding its approved outputs
+to ordinary Parameters is documented in
+[data-platform-mapping.md](data-platform-mapping.md). Kubernetes Worker image and
+Secret configuration remain platform-operator responsibilities.
 
 The following distinctions are part of the platform contract:
 

package/skills/feature-management/references/supervised-datasets.md

@@ -151,6 +151,19 @@ For a manifest split named `train`, use `["train"]`. Hand off the exact artifact
 identity, DataSchema hash, FeatureSet order, label/temporal contracts, observed
 split counts and binding together.
 
+When the same immutable DatasetArtifact must be evaluated with different date
+boundaries, use the TrainingRun level derived binding instead of rebuilding the
+artifact. The supported forms are `mode: derived`, with `strategy: time_range`
+or `chronological_ratio`. Time ranges use timezone aware half open
+ranges for `train`, `validation` and optional `test`. The resolver freezes row identities and uses
+the prediction time column as the sample start. It removes rows whose
+`label_time` crosses that role's end boundary and reports the count; it never
+moves or rewrites the label. `test` remains an independent evaluation role,
+`chronological_ratio` keeps equal prediction timestamps together. Actual counts
+can differ from requested ratios. The ordinary
+`assignment_column` form remains the compatibility path for artifacts that
+already contain a split column.
+
 ## Evidence checkpoints
 
 SQL-source `verifiable=false` means the automatic clock analysis could not

package/skills/model-deployment-management/SKILL.md

@@ -46,6 +46,10 @@ deployment does not reach `READY` or an operation is rejected.
   returned an ambiguous result.
 - Treat `READY` as valid only when `ReplicasReady`, `ArtifactsVerified`, and
   `SmokePredictionPassed` are all true for the current revision.
+- A READY staging revision can use unified prediction and scheduled reporting.
+  Do not promote merely to enable either workflow. Promote only when the user
+  requests routed canary/production traffic; unified prediction selects the
+  deployment's current revision and does not split traffic by canary weight.
 - Use `predict-deployment` for governed deployment verification. Do not infer
   Kubernetes Service names from a deployment ID.
 - Treat every prediction response `target_time` as China Standard Time in RFC

package/skills/model-deployment-management/references/contracts.md

@@ -72,6 +72,12 @@ continues to carry them in `inputs.future_covariates`.
 The first deployment starts at `staging`. A replacement for an existing
 service/environment declares the active leaf in `previous_deployment_id`.
 Production is reached only by staging to canary to production promotion.
+This stage sequence governs routed rollout, not eligibility for unified prediction
+or reporting: a READY staging revision is sufficient for those workflows.
+New promotion requires `service_exposure.type=Ingress` or an explicit
+`rollout.gateway_name`. NodePort alone does not provide weighted routing.
+The server checks routing prerequisites before persisting the promoted revision;
+a rejected preflight preserves the existing revision and its READY state.
 
 `service_exposure` is optional and defaults to `{"type":"ClusterIP"}`. Set
 `type=NodePort` only when direct node access is required. `node_port` is

package/skills/model-deployment-management/references/operations.md

@@ -78,6 +78,20 @@ exposure mode.
 
 ## Promotion And Approval
 
+Skip this step for ordinary unified prediction or scheduled reports on a READY
+staging deployment. For weighted traffic, use an environment's existing
+ingress-nginx with `service_exposure.type=Ingress`, or an explicitly bound,
+ready Gateway via `rollout.gateway_name`. Inspect the immutable DeploymentSpec
+first; changing exposure requires a reviewed replacement deployment. Do not
+install a Gateway merely because the default ClusterIP or NodePort deployment
+cannot be promoted.
+
+Promotion performs Kubernetes routing dry-run admission before saving a new
+revision. This checks API permissions and admission, not live ingress-controller
+health or end-to-end reachability. Continue observing reconciliation and READY
+conditions after an accepted promotion. Canary weights apply to the routed
+entrypoint; `predict-deployment` directly verifies the selected revision.
+
 ```bash
 ml-platform --profile server promote-deployment <deployment-id> \
   --stage canary --actor <actor> --reason <reason>

package/skills/model-deployment-management/references/troubleshooting.md

@@ -10,6 +10,14 @@ ml-platform --profile server get-deployment-events <deployment-id> \
 
 Interpret conditions before considering a reconcile:
 
+- A rejected promotion mentioning `rollout.gateway_name`, Gateway HTTP status,
+  or routing RBAC leaves the current revision unchanged. Check it with
+  `get-deployment`; if staging is READY, unified prediction and reporting remain
+  usable. Use existing Ingress for intentional canary traffic, or correct the
+  explicit Gateway binding and permissions. Do not repeatedly promote to make
+  ordinary prediction work. Historical FAILED promotion revisions are not
+  automatically repaired by this guard; inspect the active replacement before
+  planning recovery.
 - `ReplicasReady=false`: inspect scheduler, image pull, resource quota, and Pod
   readiness through the platform/cluster diagnostic boundary.
 - `ArtifactsVerified=false`: the Serving `/model` identity does not match the

package/skills/model-lifecycle-management/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: model-lifecycle-management
-description: Manage ITSMP system-model discovery, model training, evaluation, immutable model packaging, and contract-bound inference requests. Use when a user asks to inspect platform-owned SystemModels and runtime bindings, validate or submit a training run, inspect/retry/cancel training jobs, configure or run governed evaluation, inspect evaluation evidence, validate a ModelArtifact, create and inspect a ModelPackage, or invoke a deployed model. Do not use for feature catalog authoring, dataset builds, model deployment, Kubernetes administration, or image release engineering.
+description: Manage ITSMP system-model discovery, model training, evaluation, controlled model comparison and feature/input ablation, immutable model packaging, and contract-bound inference requests. Use when a user asks to inspect platform-owned SystemModels and runtime bindings, validate or submit a training run, run a baseline/variant ablation experiment, inspect/retry/cancel training jobs, configure or run governed evaluation, inspect evaluation evidence, validate a ModelArtifact, create and inspect a ModelPackage, or invoke a deployed model. Do not use for feature catalog authoring, dataset builds, model deployment, Kubernetes administration, or image release engineering.
 ---
 
 # Model Lifecycle Management
@@ -31,10 +31,16 @@ resources or selecting runtime bindings. It also defines Job/package preflight
 and version-skew handling.
 
 For multiple-model experiments or iterative optimization, read
-[references/model-comparison.md](references/model-comparison.md). This method
-uses platform CLI contracts and works without an ITSMP TUI or a specific Agent
-Runtime. An execution host may additionally persist plans, method hashes,
-attempts and checkpoints; those records do not replace platform evidence.
+[references/model-comparison.md](references/model-comparison.md) and
+[references/experiment-runs.md](references/experiment-runs.md). Use the
+platform's durable `ExperimentRun` to associate candidates and reconcile jobs.
+The method still comes from this Skill; ExperimentRun does not select a winner
+or deploy a model.
+
+For feature or input ablation experiments, also read
+[references/ablation.md](references/ablation.md). Ablation is a comparison
+protocol represented by `ExperimentRun` and linked to ordinary TrainingRun and
+EvaluationRun resources; there is no separate `AblationRun` API.
 
 For unsupervised clustering (`task.kind=clustering`, for example
 `kmeans_clusterer` or `gaussian_mixture_clusterer`), read the clustering

package/skills/model-lifecycle-management/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "模型训练、评估与打包"
-  short_description: "管理 ITSMP 模型训练、评估与不可变模型打包流程"
-  default_prompt: "使用 $model-lifecycle-management 管理模型训练、评估或打包流程。"
+  short_description: "管理 ITSMP 模型训练、评估、比较与消融实验"
+  default_prompt: "使用 $model-lifecycle-management 管理模型训练、评估、比较或消融实验流程。"

package/skills/model-lifecycle-management/references/ablation.md

@@ -0,0 +1,111 @@
+# Feature and input ablation
+
+Use this method when the question is whether a feature, feature group,
+covariate, input channel or preprocessing input contributes to a model result.
+It is a controlled comparison protocol represented by an `ExperimentRun`. The
+run links existing `TrainingRun`, `ModelArtifact`, `EvaluationRun` and
+`EvaluationResult` facts. Read [experiment-runs.md](experiment-runs.md) for
+execution and [model-comparison.md](model-comparison.md) for evidence rules.
+
+## Freeze the baseline scope
+
+Define one baseline candidate with the complete approved input FeatureSet and
+freeze these values for the whole ablation round:
+
+- the exact `DatasetArtifact` and `manifest_hash`;
+- DataSchema, label columns, prediction/label time semantics and series keys;
+- train/validation/test assignment and rowset population;
+- evaluation config, metric versions, calculation space and slices;
+- SystemModel, runtime release, reproducibility settings and execution policy.
+
+The baseline is the full input set for the hypothesis being tested. A model
+name, FeatureSet name or metric value is not enough to identify it. Store the
+baseline and variants in one immutable ExperimentRun spec.
+
+## Define variants
+
+Create one candidate per removal or replacement under test. Prefer one-factor
+variants:
+
+```text
+baseline: [load, temperature, pressure, calendar]
+remove_load: [temperature, pressure, calendar]
+remove_weather: [load, pressure, calendar]
+remove_calendar: [load, temperature, pressure]
+```
+
+Keep the retained columns in their declared order. Give every candidate a
+stable candidate ID, a short hypothesis, the exact removed input keys and the
+parent baseline candidate ID in the ExperimentRun spec. Do not change hyperparameters,
+labels, splits or evaluation policy at the same time as the ablated input.
+If several inputs must be removed together for a single hypothesis, name that
+group explicitly and do not interpret the result as the contribution of each
+member separately.
+
+For a feature-only ablation, bind each candidate to an immutable registered
+FeatureSet that is an allowed subset/order projection of the same artifact.
+The wide DatasetArtifact normally does not need rebuilding. Use
+`$feature-management` to create or discover those FeatureSet versions; do not
+edit an existing FeatureSet in place. If the hypothesis changes source data,
+operator logic, label materialization, row membership, or feature values in
+the artifact, create a new DatasetArtifact and start a separate comparison
+scope instead of calling it a feature ablation.
+
+## Execute the round
+
+1. Create one ExperimentRun with the immutable dataset identity, evaluation
+   contract, baseline candidate and variants. Use
+   [experiment-runs.md](experiment-runs.md) for the JSON shape.
+2. Validate all candidates before submitting any Job. Validation must show each
+   candidate FeatureSet, projected input columns, schema hash and runtime
+   identity. Validation has no training side effects.
+3. Submit only within the user's authorized training scope. Reconcile the
+   ExperimentRun after uncertain responses; never create a replacement run to
+   retry an unknown candidate submission.
+4. Observe every Job and validate its ModelArtifact. A failed or infrastructure
+   Job has no model-quality score and must be reported separately.
+5. Evaluate every successful artifact on the same frozen validation rowset with
+   the same EvaluationConfig. Inspect coverage, required decisions and result
+   hashes; do not compute replacement metrics locally.
+6. Inspect the ExperimentRun comparison on complete, comparable results. Use
+   the baseline as the reference and report absolute and relative metric
+   deltas. For metrics where lower is better, a positive candidate-minus-
+   baseline delta is degradation; follow the MetricDefinition rather than
+   assuming direction.
+
+Example comparison request:
+
+```json
+{
+  "schema_version": "ml_data_platform.evaluation_result_comparison_request/v1",
+  "comparison_type": "model",
+  "result_ids": ["baseline_result", "remove_load_result"],
+  "metrics": ["regression.mae", "regression.rmse"],
+  "sort_direction": "ascending"
+}
+```
+
+Do not rank candidates with different rowsets, labels, horizons, metric
+definitions or incomplete coverage. A candidate that fails because of a
+runtime, image or contract problem is inconclusive about the ablated input.
+
+## Interpret and close the round
+
+Report, for every candidate, the baseline/variant FeatureSet identities, exact
+removed inputs, TrainingRun/Job/ModelArtifact IDs, EvaluationResult IDs,
+coverage, metrics, deltas and failure evidence. A small metric difference is
+not proof that an input is useless; state the observed tolerance and whether
+the experiment had repeated seeds or uncertainty estimates. If the result is
+inconclusive, keep the input undecided rather than deleting it.
+
+Only after validation comparison selects a candidate may the normal held-out
+test procedure in `model-comparison.md` be used. The test result validates the
+locked candidate and must not be used to choose another ablation. Packaging,
+registration and deployment remain separate authorized gates.
+
+The round is complete only when every submitted candidate is accounted for as
+complete, failed, pending, unknown or skipped with a reason. Stop when the
+declared ablation set is covered, the authorized training scope is exhausted,
+or a shared data/runtime defect blocks the round. Do not add an automatic
+feature deletion threshold; business owners decide the practical impact and
+tradeoff after reviewing comparable evidence.

package/skills/model-lifecycle-management/references/evaluation.md

@@ -51,6 +51,43 @@ Inspect `get-metric-definition regression.mae v1` before relying on this metric.
 Release mode additionally requires at least one required validation rule with a
 business-approved threshold; do not invent thresholds to obtain PASS.
 
+`regression.hit_rate:v1` is available for point-prediction regression metrics.
+Set `parameters.tolerance` in the metric entry; tolerance is a finite,
+nonnegative absolute error in the target's units, and equality counts as a hit:
+
+```json
+{
+  "name": "regression.hit_rate", "version": "v1",
+  "targets": ["future_pressure"], "calculation_space": "business",
+  "parameters": {"tolerance": 5.0}
+}
+```
+
+The result is the fraction of valid rows whose absolute prediction error is at
+most the tolerance. The resolved tolerance is recorded in each MetricResult and
+must match when results are summarized or compared. It is an absolute threshold,
+not a percentage; choose it using the target's unit and business acceptance
+criteria.
+
+To calculate per-day metrics on China Standard Time dates, add the time bucket
+contract to the registered EvaluationConfig:
+
+```json
+{
+  "time_buckets": {
+    "width": "1d",
+    "timezone": "Asia/Shanghai",
+    "alignment": "left"
+  }
+}
+```
+
+`timezone` accepts IANA timezone names and defaults to `UTC`. Daily buckets use
+local calendar midnights and half-open intervals, so a bucket is keyed by the
+local date; use `dimension: "time_bucket"` when creating an analysis view from
+the resulting EvaluationResult IDs. The configured timezone is part of the
+immutable EvaluationConfig identity.
+
 For a fixed-length multi-step forecast, `regression.mae` and
 `regression.rmse` cover only the terminal point at the maximum trained horizon.
 Use `regression.trajectory_mae` and `regression.trajectory_rmse` for a release
@@ -237,7 +274,7 @@ Training feedback (`cluster_count`, `min_cluster_share`,
 | Symptom | Actual check and next action |
 | --- | --- |
 | `requires a named split` | Inherited TrainingRun `data.splits` is not a dictionary and requested rowset is not `all`. Inspect the original training request, not only manifest/resolved/Parquet splits. This check has no horizon-zero branch. |
-| `rowset is not declared` | Inspect `data.splits` role keys (`train`, `validation`, `test`), nonempty value arrays, assignment column and observed values. Manifest `training` can map to consumer role `train`. |
+| `rowset is not declared` | Inspect `data.splits` role keys (`train`, `validation`, `test`). For an ordinary binding, check nonempty value arrays, assignment column and observed values. For `mode: derived`, check the timezone-aware `strategy: time_range` ranges and the resolved row counts. Manifest `training` can map to consumer role `train`. |
 | DataSchema mismatch | Compare the full schema with the trained Job's hash, including split columns, roles and dtypes. Do not remove columns or falsify hashes to pass. |
 | Label leakage | Materialize label columns separately from FeatureSet order; input selection alone cannot repair the contract. |
 | Chronos-2 runtime unavailable | Record executor, error stage/Job, runtime identity and Worker image evidence. The prediction plugin cannot load a dependency; request runtime support from the platform owner. New dataset/model versions do not install dependencies. |
@@ -315,6 +352,23 @@ ml-platform --profile server publish-executable-package <name> <version>
 
 Custom metric packages must be deterministic, digest-bound, network-restricted, verified, and separately authorized for publication.
 
+The published wheel entrypoint is called as `entrypoint(inputs, context)` in an
+isolated evaluation worker. `inputs` contains only the declared arrays (for
+example `label`, `prediction`, `probability`, and `weight`). `context` contains
+the frozen metric identity and the resolved parameters for this evaluation under
+`context["parameters"]`; read that mapping instead of relying on package or
+process globals. Parameter validation happens when the EvaluationConfig is
+resolved, and the resolved values are persisted in the MetricResult and its
+comparison/summary evidence. A package metric that declares no parameter schema
+must reject supplied parameters.
+
+```python
+def score(inputs, context):
+    tolerance = float(context["parameters"]["tolerance"])
+    error = abs(inputs["prediction"] - inputs["label"])
+    return float((error <= tolerance).mean())
+```
+
 ```bash
 ml-platform --profile server validate-evaluation-run evaluation-request.json
 ml-platform --profile server submit-evaluation evaluation-request.json

package/skills/model-lifecycle-management/references/experiment-runs.md

@@ -0,0 +1,59 @@
+# ExperimentRun
+
+`ExperimentRun` is the platform control-plane record for a finite comparison
+over one frozen `DatasetArtifact`. It supports model comparison, feature/input
+ablation and a small candidate matrix while reusing existing TrainingRun,
+TrainingJob, ModelArtifact, EvaluationRun, EvaluationResult and
+EvaluationComparison records.
+
+It does not implement AutoML, a general DAG engine, automatic model selection,
+packaging or deployment. The Skill owns the modeling method and stopping rules;
+the platform owns durable candidate state and reconciliation.
+
+## Lifecycle
+
+Use the installed `ml-platform` CLI:
+
+```text
+ml-platform create-experiment-run SPEC.json
+ml-platform validate-experiment-run RUN_ID
+ml-platform submit-experiment-run RUN_ID
+ml-platform get-experiment-run RUN_ID
+ml-platform list-experiment-candidates RUN_ID --limit 50 --offset 0
+ml-platform reconcile-experiment-run RUN_ID
+ml-platform cancel-experiment-run RUN_ID
+```
+
+Create is idempotent for the same `experiment_run_id` and immutable
+`spec_hash`. Always validate before submit. Validation resolves every candidate's
+TrainingJob snapshot and has no training side effects. Submit is the mutation
+that may create TrainingJob records, subject to `max_parallelism`.
+
+## Candidate contract
+
+The spec must contain at least two candidates, a baseline candidate, one
+DatasetArtifact identity and one evaluation contract. Each candidate carries a
+complete TrainingRun v4 JSON object, a stable `candidate_id`, an optional
+hypothesis and parent candidate, and an execution policy. Candidate FeatureSets
+may be different exact-version subset/order projections of the same wide
+DatasetArtifact. Labels, split membership, temporal semantics, evaluation
+configuration and comparison population remain shared.
+
+## Recovery rules
+
+`UNKNOWN` means the platform cannot prove whether a remote submission happened.
+Reconcile first queries the durable TrainingJob/EvaluationRun records. It may
+resume only when the lifecycle record proves no remote submission was reached;
+it never blindly retries an unknown Kubernetes operation. An unknown candidate
+also stops new candidate submissions until it is reconciled. A known terminal
+failure is preserved and does not consume a parallel slot for independent
+candidates.
+
+## Completion
+
+Every candidate must be `RESULT_READY`, `FAILED`, `SKIPPED` or otherwise
+accounted for. The service calls the existing EvaluationComparison implementation
+only after complete results exist. `COMPLETE` with `ranking_allowed=true` requires
+complete evidence, comparable population and a release-mode EvaluationConfig;
+otherwise the run is `INCONCLUSIVE`. A result never authorizes registration,
+packaging or deployment by itself.

package/skills/model-lifecycle-management/references/model-comparison.md

@@ -1,10 +1,16 @@
 # Comparing models within one experiment
 
+Feature or input ablation is the controlled one-factor variant of this
+workflow. Read [ablation.md](ablation.md) for the baseline, removal-set and
+round-closeout rules; the comparison gates below still apply.
+
 Use one documented goal and user-authorized scope: metric, target, candidate
 constraints and any maximum number of training submissions. Preserve that goal
 when a follow-up changes a constraint or asks for verification. Reuse existing
 authorization when it covers the next action; ask only for missing decisions.
 No TUI, session service, or Runtime-specific tool is required for this method.
+Persist the candidate set and execution links in an `ExperimentRun`; see
+[experiment-runs.md](experiment-runs.md) for its CLI lifecycle.
 
 ## Shared scope and candidate execution
 
@@ -45,9 +51,8 @@ forecast horizon, and do not let trajectory construction cross split
 boundaries. Compare complete platform-produced EvaluationResults only after
 each candidate passes its own TrainingRun and evaluation preflight.
 
-For each candidate, record its hypothesis, exact changed inputs, parent attempt
-if any, request JSON and returned immutable IDs in the agent's working
-directory. Submit within the user's authorization, observe the TrainingJob,
+For each candidate, record its hypothesis, exact changed inputs and parent
+candidate in the ExperimentRun spec. Submit within the user's authorization, observe the TrainingJob,
 validate the resulting ModelArtifact, then submit and inspect governed
 evaluation. Explain the observed result before choosing another candidate.
 Do not resubmit after an unknown outcome: reconcile the existing Job or retry
@@ -57,12 +62,9 @@ the authorization described in the training reference.
 ## Rounds, failure evidence and stopping
 
 A round groups candidates that test a related hypothesis under the frozen
-comparison scope. Keep a small round record in the agent's working directory
-(outside a platform source checkout), using normal file tools. Include the
-scope/request paths, candidate identities and changes, submission IDs, observed
-status, result IDs, per-candidate reflection and the round's next decision.
-This is an agent work record, not a new platform resource or required tool.
-Update it after submissions and observations so another coding agent can resume.
+comparison scope. ExperimentRun and its candidates are the durable execution
+record. Keep any additional method reflection in the agent's working directory
+without duplicating platform status or IDs.
 
 When a candidate fails, inspect the actual Job status, attempts and diagnostic
 evidence. Distinguish a model execution failure from a runtime/infrastructure

package/skills/model-lifecycle-management/references/training.md

@@ -54,6 +54,40 @@ it does not reconstruct it from manifest `rowset_splits`. Save the submitted
 TrainingRun JSON, validation output, Job ID and ModelArtifact ID in the user's
 working directory so later diagnosis needs no source repository.
 
+For a second experiment over the same immutable DatasetArtifact, a TrainingRun
+may freeze a time based split without adding a split column to the artifact:
+
+```json
+{
+  "splits": {
+    "mode": "derived",
+    "strategy": "time_range",
+    "source_rowsets": ["all"],
+    "ranges": {
+      "train": {"start": "2026-01-01T00:00:00+08:00", "end": "2026-07-01T00:00:00+08:00"},
+      "validation": {"start": "2026-07-01T00:00:00+08:00", "end": "2026-08-01T00:00:00+08:00"},
+      "test": {"start": "2026-08-01T00:00:00+08:00", "end": "2026-09-01T00:00:00+08:00"}
+    }
+  }
+}
+```
+
+`time_range` uses timezone aware, left closed/right open prediction time
+intervals and requires unique row keys. The platform freezes each role's row
+identity in the resolved TrainingJob and rechecks it in the Worker. Samples
+whose `label_time` reaches or passes their role's end are excluded and counted
+in the validation snapshot; if that leaves no train samples, validation fails.
+Training time evaluation must explicitly use `train` or `validation`; `test`
+is reserved for an independent EvaluationRun. For `chronological_ratio`, provide
+`ratios` with `train`, `validation` and `test` values summing to `1`; equal
+prediction timestamps stay together. Actual counts may differ from requested
+ratios, and the algorithm version and row identities are frozen in the Job
+snapshot. Derived splits currently use all artifact rows as candidates; use
+`assignment_column` for artifacts containing auxiliary history or truth rows.
+Only `time_range` and `chronological_ratio` are supported. Confirm the selected
+training and evaluation Worker images support derived splits before submission.
+Existing `assignment_column` contracts keep their original behavior.
+
 ## Commands
 
 Read [training-contracts.md](training-contracts.md) when authoring a Run or Job

package/skills/prediction-report-management/SKILL.md

@@ -28,6 +28,9 @@ schedule request or deployment policy. A clustering deployment (its model
 artifact has `output_bindings`) has no horizon: omit `horizon` and
 `output_window`, which are rejected. A report run may be `SKIPPED` when the
 selected revision is not READY.
+A READY staging revision is eligible; reporting does not require canary or
+production promotion, an Ingress, or a Gateway. Do not promote a deployment
+just to enable its report schedule.
 
 ## Configure a destination