@ekairos/dataset 1.22.95-beta.development.0 → 1.22.96-beta.development.0

package/dist/builder/persistence.js

@@ -1,6 +1,6 @@
 import { DatasetService } from "../service.js";
 import { datasetDomain } from "../schema.js";
-import { inferQueryNotation, verifyDatasetNotation, } from "../notation.js";
+import { annotateNotationEvidence, inferQueryNotation, } from "../notation.js";
 import { datasetGetByIdStep, datasetPreviewRowsStep, datasetReadOneStep, datasetReadRowsStep, } from "../dataset/steps.js";
 import { inferDatasetSchema, validateRows } from "./schemaInference.js";
 import { rowsToJsonl } from "./rows.js";
@@ -79,9 +79,9 @@ export async function materializeRowsToDataset(runtime, params) {
         throw new Error(statusResult.error);
     }
     // Formal notation, informative only (never blocks the build): a notation
-    // proposed during the build (agent iterations) is verified against the
-    // materialized rows; query-backed builds with no proposed notation get
-    // the deterministic one derived from query + schema + rows.
+    // proposed during the build (agent iterations) gets advisory evidence
+    // against the materialized rows; query-backed builds with no proposed
+    // notation get the deterministic one derived from query + schema + rows.
     try {
         const existing = await service.getDatasetById(params.datasetId);
         const previous = (existing.ok ? existing.data?.notation : null);
@@ -100,7 +100,7 @@ export async function materializeRowsToDataset(runtime, params) {
         if (candidate) {
             await service.updateDatasetNotation({
                 datasetId: params.datasetId,
-                notation: verifyDatasetNotation(candidate, params.rows),
+                notation: annotateNotationEvidence(candidate, params.rows),
             });
         }
     }

package/dist/completeDataset.steps.js

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import { getDatasetOutputPath } from "./datasetFiles.js";
-import { verifyDatasetNotation } from "./notation.js";
+import { annotateNotationEvidence } from "./notation.js";
 import { DatasetService } from "./service.js";
 import { getDatasetRuntimeDb } from "./dataset/steps.js";
 import { readDatasetSandboxFileStep, readDatasetSandboxTextFileStep, runDatasetSandboxCommandStep, } from "./sandbox/steps.js";
@@ -177,18 +177,18 @@ export async function persistDatasetStep({ runtime, datasetId, sandboxId, summar
     }
     console.log(`[Dataset ${datasetId}] Dataset marked as COMPLETED (${totalValidRows} valid rows)`);
     console.log(`[Dataset ${datasetId}] ========================================`);
-    // Formal-notation verification: arithmetic checks of the latest notation
-    // against the produced rows. Informative only — a failure here never
-    // affects the dataset completion result.
+    // Formal-notation evidence: advisory arithmetic annotation of the latest
+    // notation against the produced rows. Informative only — it never
+    // affects the dataset completion result or the dataset's validity.
     try {
-        await verifyNotationAgainstJsonl({
+        await annotateNotationFromJsonl({
             service,
             datasetId,
             jsonlBase64: fileRead.contentBase64,
         });
     }
     catch (error) {
-        console.error(`[Dataset ${datasetId}] notation verification skipped:`, error instanceof Error ? error.message : String(error));
+        console.error(`[Dataset ${datasetId}] notation annotation skipped:`, error instanceof Error ? error.message : String(error));
     }
     return {
         success: true,
@@ -201,8 +201,8 @@ export async function persistDatasetStep({ runtime, datasetId, sandboxId, summar
         dataFileId: uploadResult.data.fileId,
     };
 }
-const NOTATION_VERIFY_MAX_ROWS = 50000;
-async function verifyNotationAgainstJsonl(params) {
+const NOTATION_EVIDENCE_MAX_ROWS = 50000;
+async function annotateNotationFromJsonl(params) {
     const existing = await params.service.getDatasetById(params.datasetId);
     const notation = (existing.ok ? existing.data?.notation : null);
     if (!notation || !Array.isArray(notation.predicates) || notation.predicates.length === 0) {
@@ -223,17 +223,19 @@ async function verifyNotationAgainstJsonl(params) {
         catch {
             // malformed lines were already handled by schema validation
         }
-        if (rows.length >= NOTATION_VERIFY_MAX_ROWS)
+        if (rows.length >= NOTATION_EVIDENCE_MAX_ROWS)
             break;
     }
-    const verified = verifyDatasetNotation(notation, rows);
+    const annotated = annotateNotationEvidence(notation, rows);
     await params.service.updateDatasetNotation({
         datasetId: params.datasetId,
-        notation: verified,
+        notation: annotated,
     });
-    const failed = (verified.checks ?? []).filter((check) => check.status === "failed");
-    console.log(`[Dataset ${params.datasetId}] notation v${verified.version} ${verified.status}` +
-        (failed.length ? ` (${failed.length} predicados violados)` : ""));
+    const contradicted = (annotated.checks ?? []).filter((check) => check.status === "contradicted");
+    console.log(`[Dataset ${params.datasetId}] notation v${annotated.version} (${annotated.status})` +
+        (contradicted.length
+            ? ` — ${contradicted.length} predicado(s) con evidencia contraria (advisory)`
+            : ""));
 }
 function resolveExecutionStoragePath(outputPath, datasetId) {
     const normalized = String(outputPath ?? "").replace(/\\/g, "/");

package/dist/file/prompts.js

@@ -245,9 +245,9 @@ function buildInstructions(context) {
         .ele("Requirement").txt("The notation is your PLANNING artifact: it comes BEFORE the schema and BEFORE any parsing code. The LaTeX that explains the dataset matters more than the code that produces it").up()
         .ele("Requirement").txt("Use set-builder notation, quantifiers and arithmetic in LaTeX (e.g. D = \\{(c, q, p) \\mid q \\in \\mathbb{Z}^{+},\\; p \\in \\mathbb{R}_{\\geq 0}\\})").up()
         .ele("Requirement").txt("Declare every discovered set and variable as a symbol with a one-line meaning").up()
-        .ele("Requirement").txt("Give predicates a machine-checkable checkJson whenever the claim is arithmetic (row counts, field types, ranges, uniqueness, aggregates); leave semantic-only claims without checkJson").up()
+        .ele("Requirement").txt("Predicates are formal claims we trust; they may be semantic (e.g. 'x es una frase relevante'). Only for the few that are purely arithmetic (row counts, field types, ranges, uniqueness, aggregates) you MAY add a checkJson for optional advisory evidence — leave every other claim without checkJson").up()
         .ele("Requirement").txt("ITERATE: every time the analysis discovers a new set, variable, constraint or correction (new columns, unexpected types, excluded sections), call proposeNotation again with the refined notation and the reason. The notation is not definitive — discovery is the point").up()
-        .ele("Requirement").txt("Before calling completeDataset, call proposeNotation one last time with final=true so the notation describes EXACTLY the dataset you produced; its checkable predicates will be verified arithmetically against the rows").up()
+        .ele("Requirement").txt("Before calling completeDataset, call proposeNotation one last time with final=true so the notation describes EXACTLY the dataset you produced; any arithmetic predicates get optional advisory evidence afterwards (never a pass/fail verdict — the dataset's validity is trusted)").up()
         .up()
         .up();
     if (hasProvidedSchema) {

package/dist/notation.d.ts

@@ -1,19 +1,29 @@
 /**
  * Formal notation for datasets.
  *
- * A dataset is the materialization of a set defined by formal notation:
+ * A dataset is the materialization of a set defined by FORMAL NOTATION:
  * LaTeX (set-builder, relational algebra, quantified predicates) that
  * EXPLAINS the data — what sets it draws from, what variables it binds,
- * what constraints every row satisfies. The notation is the planning
- * artifact: it starts as a proposal from the first look at the resources
- * and is ITERATED as the analysis discovers new sets, variables and
- * invariants. The final notation describes the produced dataset and its
- * machine-checkable predicates are verified with plain arithmetic over
- * the actual rows (propositional combinations supported).
+ * what every member satisfies. The definition is a logical proposition,
+ * possibly DERIVED (a syllogism), so it is NOT, in general, mechanically
+ * verifiable: a predicate may be semantic ("x es una frase divertida"),
+ * and the set is still perfectly well-formed. We TRUST that the formality
+ * and the produced dataset are valid — formal notation is the planning
+ * and explanatory artifact, not a proof obligation.
  *
- * Verification is informative, never blocking: a dataset completes the
- * same way it always did; the notation carries its own verified/violated
- * state alongside.
+ * It is the planning artifact: it starts as a proposal from the first look
+ * at the resources and is ITERATED as the analysis discovers new sets,
+ * variables and constraints. The notation is not definitive — discovery is
+ * the point.
+ *
+ * SOME predicates happen to be arithmetic (a row count, a field type, a
+ * preserved total). For those, and only those, we can attach OPTIONAL
+ * arithmetic evidence computed over the produced rows. That evidence is
+ * advisory: a contradiction is a hint worth surfacing, never a verdict
+ * that the dataset is invalid. Predicates with no arithmetic form are
+ * "asserted" — formal claims we trust. Nothing here blocks or changes a
+ * dataset build; the notation simply rides alongside on
+ * dataset_datasets.notation.
  */
 export type DatasetNotationSymbolKind = "set" | "variable" | "function" | "constant" | "predicate";
 export type DatasetNotationSymbol = {
@@ -26,10 +36,12 @@ export type DatasetNotationSymbol = {
 };
 export type NotationCmpOp = "=" | "!=" | "<" | "<=" | ">" | ">=";
 /**
- * Machine-checkable claims about the dataset, evaluated with plain
- * arithmetic over the rows. Field access supports dot-paths into nested
- * records ("company.taxId"). Leaf checks are dataset-level propositions;
- * and/or/not/implies compose them propositionally.
+ * OPTIONAL arithmetic evidence for the subset of predicates that happen to
+ * be mechanical (counts, types, ranges, totals). Evaluated over the rows;
+ * field access supports dot-paths into nested records ("company.taxId").
+ * Leaf checks are dataset-level propositions; and/or/not/implies compose
+ * them propositionally. A predicate WITHOUT a check is a formal/semantic
+ * claim we trust — that is the normal case, not an exception.
  */
 export type NotationCheck = {
     kind: "row_count";
@@ -88,12 +100,21 @@ export type DatasetNotationPredicate = {
     description: string;
     /** the claim in LaTeX, e.g. "\\forall r \\in D:\\; r.amount > 0" */
     latex: string;
-    /** machine-checkable form; absent = semantic-only claim (not verified) */
+    /**
+     * OPTIONAL arithmetic form. Absent (the common case) = a formal/semantic
+     * claim we trust without mechanical checking.
+     */
     check?: NotationCheck;
 };
+/**
+ * Advisory evidence for one predicate. Never a verdict on the dataset:
+ * - "asserted"     formal/semantic claim, trusted, no mechanical check
+ * - "supported"    arithmetic evidence agrees with the stated claim
+ * - "contradicted" arithmetic evidence disagrees — a hint, not a failure
+ */
 export type DatasetNotationCheckResult = {
     predicateId: string;
-    status: "passed" | "failed" | "skipped";
+    status: "asserted" | "supported" | "contradicted";
     detail?: string;
 };
 export type DatasetNotationRevision = {
@@ -103,7 +124,13 @@ export type DatasetNotationRevision = {
     reason: string;
     at: number;
 };
-export type DatasetNotationStatus = "proposed" | "refined" | "final" | "verified" | "violated";
+/**
+ * Lifecycle of the formal notation. There is intentionally NO
+ * "verified"/"violated" verdict — the dataset's validity is trusted, not
+ * proven. Advisory arithmetic evidence (when any predicate has it) lives
+ * in `checks`, separate from this status.
+ */
+export type DatasetNotationStatus = "proposed" | "refined" | "final";
 export type DatasetNotation = {
     version: number;
     status: DatasetNotationStatus;
@@ -111,8 +138,10 @@ export type DatasetNotation = {
     latex: string;
     symbols: DatasetNotationSymbol[];
     predicates: DatasetNotationPredicate[];
+    /** advisory per-predicate evidence (asserted/supported/contradicted) */
     checks?: DatasetNotationCheckResult[];
-    verifiedAt?: number;
+    /** when the advisory evidence was last computed */
+    evidenceAt?: number;
     history: DatasetNotationRevision[];
 };
 export type NotationRevisionInput = {
@@ -139,8 +168,10 @@ type JsonSchemaLike = {
 /**
  * A query-backed dataset has a complete deterministic description: the
  * dataset is the image of a known query over a known domain. No model is
- * involved — the notation and its checkable predicates derive mechanically
- * from the query, the inferred schema and the produced row count.
+ * involved, so here the formal definition and its predicates derive
+ * mechanically from the query, the inferred schema and the row count — and
+ * those predicates DO carry arithmetic evidence (the special case where the
+ * formal claims happen to be fully mechanical).
  */
 export declare function inferQueryNotation(params: {
     entityNames: string[];
@@ -154,10 +185,17 @@ type CheckOutcome = {
 };
 export declare function evaluateNotationCheck(rows: any[], check: NotationCheck): CheckOutcome;
 /**
- * Verify a notation against produced rows. Pure arithmetic — never throws.
- * Predicates without a machine-checkable form are reported as "skipped"
- * (they remain semantic claims). Returns the notation with check results
- * and a verified/violated status.
+ * Annotate a notation with ADVISORY arithmetic evidence over the produced
+ * rows. Never throws, never blocks, and never changes the notation's
+ * lifecycle status — the dataset's validity is trusted, not proven here.
+ *
+ * Each predicate is reported as:
+ * - "asserted"     no arithmetic form (formal/semantic claim, trusted)
+ * - "supported"    arithmetic evidence agrees
+ * - "contradicted" arithmetic evidence disagrees (a hint to look, not a
+ *                  verdict that the dataset is wrong)
+ * A check that can't be evaluated stays "asserted" — we don't downgrade a
+ * trusted claim because of a malformed mechanical form.
  */
-export declare function verifyDatasetNotation(notation: DatasetNotation, rows: any[]): DatasetNotation;
+export declare function annotateNotationEvidence(notation: DatasetNotation, rows: any[]): DatasetNotation;
 export {};

package/dist/notation.js

@@ -1,19 +1,29 @@
 /**
  * Formal notation for datasets.
  *
- * A dataset is the materialization of a set defined by formal notation:
+ * A dataset is the materialization of a set defined by FORMAL NOTATION:
  * LaTeX (set-builder, relational algebra, quantified predicates) that
  * EXPLAINS the data — what sets it draws from, what variables it binds,
- * what constraints every row satisfies. The notation is the planning
- * artifact: it starts as a proposal from the first look at the resources
- * and is ITERATED as the analysis discovers new sets, variables and
- * invariants. The final notation describes the produced dataset and its
- * machine-checkable predicates are verified with plain arithmetic over
- * the actual rows (propositional combinations supported).
+ * what every member satisfies. The definition is a logical proposition,
+ * possibly DERIVED (a syllogism), so it is NOT, in general, mechanically
+ * verifiable: a predicate may be semantic ("x es una frase divertida"),
+ * and the set is still perfectly well-formed. We TRUST that the formality
+ * and the produced dataset are valid — formal notation is the planning
+ * and explanatory artifact, not a proof obligation.
  *
- * Verification is informative, never blocking: a dataset completes the
- * same way it always did; the notation carries its own verified/violated
- * state alongside.
+ * It is the planning artifact: it starts as a proposal from the first look
+ * at the resources and is ITERATED as the analysis discovers new sets,
+ * variables and constraints. The notation is not definitive — discovery is
+ * the point.
+ *
+ * SOME predicates happen to be arithmetic (a row count, a field type, a
+ * preserved total). For those, and only those, we can attach OPTIONAL
+ * arithmetic evidence computed over the produced rows. That evidence is
+ * advisory: a contradiction is a hint worth surfacing, never a verdict
+ * that the dataset is invalid. Predicates with no arithmetic form are
+ * "asserted" — formal claims we trust. Nothing here blocks or changes a
+ * dataset build; the notation simply rides alongside on
+ * dataset_datasets.notation.
  */
 /**
  * Iterate the notation: every revision bumps the version and appends to
@@ -80,8 +90,10 @@ function schemaProperties(schema) {
 /**
  * A query-backed dataset has a complete deterministic description: the
  * dataset is the image of a known query over a known domain. No model is
- * involved — the notation and its checkable predicates derive mechanically
- * from the query, the inferred schema and the produced row count.
+ * involved, so here the formal definition and its predicates derive
+ * mechanically from the query, the inferred schema and the row count — and
+ * those predicates DO carry arithmetic evidence (the special case where the
+ * formal claims happen to be fully mechanical).
  */
 export function inferQueryNotation(params) {
     const sources = params.entityNames.length ? params.entityNames : ["Domain"];
@@ -367,42 +379,44 @@ export function evaluateNotationCheck(rows, check) {
     }
 }
 /**
- * Verify a notation against produced rows. Pure arithmetic — never throws.
- * Predicates without a machine-checkable form are reported as "skipped"
- * (they remain semantic claims). Returns the notation with check results
- * and a verified/violated status.
+ * Annotate a notation with ADVISORY arithmetic evidence over the produced
+ * rows. Never throws, never blocks, and never changes the notation's
+ * lifecycle status — the dataset's validity is trusted, not proven here.
+ *
+ * Each predicate is reported as:
+ * - "asserted"     no arithmetic form (formal/semantic claim, trusted)
+ * - "supported"    arithmetic evidence agrees
+ * - "contradicted" arithmetic evidence disagrees (a hint to look, not a
+ *                  verdict that the dataset is wrong)
+ * A check that can't be evaluated stays "asserted" — we don't downgrade a
+ * trusted claim because of a malformed mechanical form.
  */
-export function verifyDatasetNotation(notation, rows) {
+export function annotateNotationEvidence(notation, rows) {
     const checks = [];
-    let failed = 0;
     for (const predicate of notation.predicates ?? []) {
         if (!predicate.check) {
-            checks.push({ predicateId: predicate.id, status: "skipped" });
+            checks.push({ predicateId: predicate.id, status: "asserted" });
             continue;
         }
         try {
             const outcome = evaluateNotationCheck(rows, predicate.check);
             checks.push({
                 predicateId: predicate.id,
-                status: outcome.ok ? "passed" : "failed",
+                status: outcome.ok ? "supported" : "contradicted",
                 detail: outcome.detail,
             });
-            if (!outcome.ok)
-                failed += 1;
         }
         catch (error) {
             checks.push({
                 predicateId: predicate.id,
-                status: "failed",
-                detail: `error de evaluación: ${String(error).slice(0, 120)}`,
+                status: "asserted",
+                detail: `no evaluable: ${String(error).slice(0, 120)}`,
             });
-            failed += 1;
         }
     }
     return {
         ...notation,
         checks,
-        status: failed === 0 ? "verified" : "violated",
-        verifiedAt: Date.now(),
+        evidenceAt: Date.now(),
     };
 }

package/dist/proposeNotation.tool.d.ts

@@ -10,8 +10,8 @@ interface ProposeNotationToolParams {
  * the analysis discovers new sets, variables, constraints or corrections.
  * Every call appends a revision (the discovery trail is preserved). Mark
  * the last call with final=true so the notation describes the produced
- * dataset; its checkable predicates get verified arithmetically after
- * completion.
+ * dataset. Predicates may be formal/semantic (we trust them); the few that
+ * are arithmetic get optional advisory evidence after completion.
  */
 export declare function createProposeNotationTool({ datasetId, runtime }: ProposeNotationToolParams): import("ai").Tool<{
     latex: string;

package/dist/proposeNotation.tool.js

@@ -22,8 +22,8 @@ const predicateSchema = z.object({
         .string()
         .optional()
         .describe([
-        "OPTIONAL machine-checkable form of the claim as a JSON string, verified",
-        "with plain arithmetic over the produced rows. Shapes:",
+        "OPTIONAL arithmetic form of the claim as a JSON string, used only for",
+        "advisory evidence over the produced rows (not a verdict). Shapes:",
         '{"kind":"row_count","op":"=","value":124}',
         '{"kind":"field_type","field":"amount","type":"number","allowNull":true}',
         '{"kind":"field_range","field":"amount","min":0}',
@@ -35,7 +35,7 @@ const predicateSchema = z.object({
         'Propositional composition: {"kind":"and"|"or","checks":[...]},',
         '{"kind":"not","check":...}, {"kind":"implies","if":...,"then":...}.',
         "Fields support dot-paths into nested records (company.taxId).",
-        "Omit for claims that are semantic only.",
+        "Omit for formal/semantic claims (the normal case) — they are trusted.",
     ].join(" ")),
 });
 async function getDatasetService(runtime) {
@@ -50,19 +50,21 @@ async function getDatasetService(runtime) {
  * the analysis discovers new sets, variables, constraints or corrections.
  * Every call appends a revision (the discovery trail is preserved). Mark
  * the last call with final=true so the notation describes the produced
- * dataset; its checkable predicates get verified arithmetically after
- * completion.
+ * dataset. Predicates may be formal/semantic (we trust them); the few that
+ * are arithmetic get optional advisory evidence after completion.
  */
 export function createProposeNotationTool({ datasetId, runtime }) {
     return tool({
         description: [
             "Declare or refine the FORMAL NOTATION of the dataset: the dataset as a",
-            "set defined in LaTeX (set-builder, relational algebra, quantified",
-            "predicates) plus the symbols it binds and the predicates every row",
-            "satisfies. This is your PLANNING artifact — propose it before writing",
-            "any code, and revise it whenever the analysis discovers new sets,",
-            "variables or invariants. The latest final notation is verified",
-            "arithmetically against the produced rows (non-blocking).",
+            "set defined in LaTeX (set-builder, relational algebra, quantified or",
+            "even semantic predicates) plus the symbols it binds. The definition is",
+            "a logical proposition, possibly derived — it does not need to be",
+            "mechanically provable; we trust the formality. This is your PLANNING",
+            "artifact — propose it before writing any code, and revise it whenever",
+            "the analysis discovers new sets, variables or constraints. For the few",
+            "predicates that happen to be arithmetic you MAY attach a checkJson for",
+            "optional advisory evidence (non-blocking, never a verdict).",
         ].join(" "),
         inputSchema: z.object({
             latex: z

package/dist/query/queryDomain.step.js

@@ -1,6 +1,6 @@
 import { DatasetService } from "../service.js";
 import { createDatasetId } from "../id.js";
-import { inferQueryNotation, verifyDatasetNotation } from "../notation.js";
+import { annotateNotationEvidence, inferQueryNotation } from "../notation.js";
 function normalizeRows(result) {
     if (!result || typeof result !== "object")
         return [];
@@ -63,9 +63,9 @@ export async function queryDomainStep(params) {
     const previewRows = rows.slice(0, 20);
     const schema = inferSchema(rows);
     // query-backed datasets carry a fully deterministic formal notation:
-    // the set definition, its symbols and its checkable predicates derive
-    // mechanically from the query + rows; verification is immediate
-    const notation = verifyDatasetNotation(inferQueryNotation({
+    // the set definition, its symbols and its predicates derive mechanically
+    // from the query + rows, so their arithmetic evidence is immediate
+    const notation = annotateNotationEvidence(inferQueryNotation({
         entityNames: Object.keys(params.query ?? {}),
         rowCount: rows.length,
         schema,

package/dist/transform/prompts.js

@@ -104,7 +104,7 @@ function buildInstructions(context) {
         .up()
         .ele("Step", { number: "2", name: "Propose Formal Notation (PLAN FIRST)" })
         .ele("Action").txt("Call proposeNotation with the formal definition of the OUTPUT dataset as a set derived from the input sets: e.g. D = \\pi_{fields}(\\sigma_{condition}(A \\bowtie B)) or set-builder with quantifiers, in LaTeX. Declare the input sets, bound variables and the predicates every output row satisfies.").up()
-        .ele("Note").txt("The notation is the planning artifact and comes BEFORE the transformation: it states which sets you draw from, how they combine (join, filter, project, aggregate) and which arithmetic invariants the output keeps (e.g. totals preserved across the transformation). Give predicates a machine-checkable checkJson whenever the claim is arithmetic (row counts, ranges, uniqueness, aggregates). ITERATE the notation whenever inspection of the inputs reveals new sets, variables or corrections, and call proposeNotation with final=true just before completing — it will be verified arithmetically against the produced rows.").up()
+        .ele("Note").txt("The notation is the planning artifact and comes BEFORE the transformation: it states which sets you draw from, how they combine (join, filter, project, aggregate) and which invariants the output keeps (e.g. totals preserved across the transformation). The definition is a formal proposition we trust — predicates may be semantic. Only for purely arithmetic invariants you MAY add a checkJson for optional advisory evidence. ITERATE the notation whenever inspection of the inputs reveals new sets, variables or corrections, and call proposeNotation with final=true just before completing — any arithmetic predicates then get advisory evidence (never a verdict).").up()
         .up()
         .ele("Step", { number: "3", name: "Plan Mapping" })
         .ele("Action").txt("Plan a deterministic mapping from input data fields to the output schema fields (normalize names, types, and formats).").up()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekairos/dataset",
-  "version": "1.22.95-beta.development.0",
+  "version": "1.22.96-beta.development.0",
   "description": "Pulzar Dataset Tools",
   "type": "module",
   "main": "dist/index.js",
@@ -65,9 +65,9 @@
     "test:ai-sdk:instant": "vitest run -c vitest.codex.config.mts src/tests/materializeDataset.ai-sdk.instant.test.ts"
   },
   "dependencies": {
-    "@ekairos/domain": "^1.22.95-beta.development.0",
-    "@ekairos/events": "^1.22.95-beta.development.0",
-    "@ekairos/sandbox": "^1.22.95-beta.development.0",
+    "@ekairos/domain": "^1.22.96-beta.development.0",
+    "@ekairos/events": "^1.22.96-beta.development.0",
+    "@ekairos/sandbox": "^1.22.96-beta.development.0",
     "@instantdb/admin": "0.22.158",
     "@instantdb/core": "0.22.142",
     "ai": "^5.0.44",