@meshxdata/fops 0.1.30 → 0.1.32

package/CHANGELOG.md

@@ -2,6 +2,378 @@
 
 All notable changes to @meshxdata/fops (Foundation Operator CLI) are documented here.
 
+## [0.1.32] - 2026-03-04
+
+- electron app (59ad0bb)
+- compose and fops file plugin (1cf0e81)
+- bump (346ffc1)
+- localhost replaced by 127.0.0.1 (82b9f30)
+- .29 (587b0e1)
+- improve up down and bootstrap script (b79ebaf)
+- checksum (22c8086)
+- checksum (96b434f)
+- checksum (15ed3c0)
+- checksum (8a6543a)
+- bump embed trino linksg (8440504)
+- bump data (765ffd9)
+- bump (cb8b232)
+- broken tests (c532229)
+- release 0.1.18, preflight checks (d902249)
+- fix compute display bug (d10f5d9)
+- cleanup packer files (6330f18)
+- plan mode (cb36a8a)
+- bump to 0.1.16 - agent ui (41ac1a2)
+- bump to 0.1.15 - agent ui (4ebe2e1)
+- bump to 0.1.14 (6c3a7fa)
+- bump to 0.1.13 (8db570f)
+- release 0.1.12 (c1c79e5)
+- bump (11aa3b0)
+- git keep and bump tui (be1678e)
+- skills, index, rrf, compacted context (100k > 10k) (7b2fffd)
+- cloudflare and token consumption, graphs indexing (0ad9eec)
+- bump storage default (22c83ba)
+- storage fix (68a22a0)
+- skills update (7f56500)
+- v9 bump (3864446)
+- bump (c95eedc)
+- rrf (dbf8c95)
+- feat: warning when running predictions (95e8c52)
+- feat: support for local predictions (45cf26b)
+- feat: wip support for predictions + mlflow (3457052)
+- add Reciprocal Rank Fusion (RRF) to knowledge and skill retrieval (61549bc)
+- validate CSV headers in compute_run readiness check (a8c7a43)
+- fix corrupted Iceberg metadata: probe tables + force cleanup on re-apply (50578af)
+- enforce: never use foundation_apply to fix broken products (2e049bf)
+- update SKILL.md with complete tool reference for knowledge retrieval (30b1924)
+- add storage read, input DP table probe, and compute_run improvements (34e6c4c)
+- skills update (1220385)
+- skills update (bb66958)
+- some tui improvement andd tools apply overwrite (e90c35c)
+- skills update (e9227a1)
+- skills update (669c4b3)
+- fix plugin pre-flight checks (f741743)
+- increase agent context (6479aaa)
+- skills and init sql fixes (5fce35e)
+- checksum (3518b56)
+- penging job limit (a139861)
+- checksum (575d28c)
+- bump (92049ba)
+- fix bug per tab status (0a33657)
+- fix bug per tab status (50457c6)
+- checksumming (0ad842e)
+- shot af mardkwon overlapping (51f63b9)
+- add spark dockerfile for multiarch builds (95abbd1)
+- fix plugin initialization (16b9782)
+- split index.js (50902a2)
+- cloudflare cidr (cc4e021)
+- cloduflare restrictions (2f6ba2d)
+- sequential start (86b496e)
+- sequential start (4930fe1)
+- sequential start (353f014)
+- qa tests (2dc6a1a)
+- bump sha for .85 (dc2edfe)
+- preserve env on sudo (7831227)
+- bump sha for .84 (6c052f9)
+- non interactive for azure vms (0aa8a2f)
+- keep .env if present (d072450)
+- bump (7a8e732)
+- ensure opa is on compose if not set (f4a5228)
+- checksum bump (a2ccc20)
+- netrc defensive checks (a0b0ccc)
+- netrc defensive checks (ae37403)
+- checksum (ec45d11)
+- update sync and fix up (7f9af72)
+- expand test for azure and add new per app tag support (388a168)
+- checksum on update (44005fc)
+- cleanup for later (15e5313)
+- cleanup for later (11c9597)
+- switch branch feature (822fecc)
+- add pull (d1c19ab)
+- Bump hono from 4.11.9 to 4.12.0 in /operator-cli (ad25144)
+- tests (f180a9a)
+- cleanup (39c49a3)
+- registry (7b7126a)
+- reconcile kafka (832d0db)
+- gh login bug (025886c)
+- cleanup (bb96cab)
+- strip envs from process (2421180)
+- force use of gh creds not tokens in envs var (fff7787)
+- resolve import between npm installs and npm link (79522e1)
+- fix gh scope and azure states (afd846c)
+- refactoring (da50352)
+- split fops repo (d447638)
+- aks (b791f8f)
+- refactor azure (67d3bad)
+- wildcard (391f023)
+- azure plugin (c074074)
+- zap (d7e6e7f)
+- fix knock (cf89c05)
+- azure (4adec98)
+- Bump tar from 7.5.7 to 7.5.9 in /operator-cli (e41e98e)
+- azure stack index.js split (de12272)
+- Bump ajv from 8.17.1 to 8.18.0 in /operator-cli (76da21f)
+- packer (9665fbc)
+- remove stack api (db0fd4d)
+- packer cleanup (fe1bf14)
+- force refresh token (3a3d7e2)
+- provision shell (2ad505f)
+- azure vm management (91dcb31)
+- azure specific (2b0cca8)
+- azure packer (12175b8)
+- init hashed pwd (db8523c)
+- packer (5b5c7c4)
+- doctor for azure vm (ed524fa)
+- packer and 1pwd (c6d053e)
+- split big index.js (dc85a1b)
+- kafka volume update (21815ec)
+- fix openai azure tools confirmation and flow (0118cd1)
+- nighly fixx, test fix (5e0d04f)
+- open ai training (cdc494a)
+- openai integration in azure (1ca1475)
+- ci (672cea9)
+- refresh ghcr creds (4220c48)
+- cleaned up version (1a0074f)
+- traefik on ghcr and templates (8e31a05)
+- apply fcl (e78911f)
+- demo landscape (dd205fe)
+- smarter login and schema (1af514f)
+- no down before up unless something broke (56b1132)
+- dai, reconcile failed containers (12907fa)
+- reconcile dead container (7da75e4)
+- defensive around storage buckets dir (b98871d)
+- defensive around storage buckets dir (e86e132)
+- gear in for multiarch (bf3fa3e)
+- up autofix (99c7f89)
+- autofix stale containers on up (43c7d0f)
+- shared sessions fix (5de1359)
+- share sessions between ui and tui (8321391)
+- fix chat view display details (e263996)
+- fix chat view display details (9babdda)
+- tui up fixes (86e9f17)
+- fix commands init (442538b)
+- enable k3s profile (b2dcfc8)
+- test up till job creation (656d388)
+- tui fixes (0599779)
+- cleanup (27731f0)
+- train (90bf559)
+- training (f809bf6)
+- training (ba2b836)
+- training (6fc5267)
+- training (4af8ac9)
+- fix build script (bd82836)
+- infra test (5b79815)
+- infra test (3a0ac05)
+- infra test (e5c67b5)
+- tests (ae7b621)
+- tests (c09ae6a)
+- update tui (4784153)
+- training (0a5a330)
+- tui (df4dd4a)
+- pkg builds (4dc9993)
+- also source env for creds (9a17d8f)
+- fcl support (e8a5743)
+- fcl support (8d6b6cd)
+- fcl support (cb76a4a)
+- bump package (df2ee85)
+- add iam mgmt (2d3c294)
+- fix k3s (976ae77)
+- fix trino, add storage plugin (75cb1f4)
+- add project root as config (a2863c6)
+- failure learnings (637ef5c)
+- Apple signed binaries (63a610e)
+- send build info to apple for notary service (300c220)
+- migration failure fixes (c7f0b2f)
+- release to wipe clean pg on duplicate key error (a38bf4d)
+- small fix (a26a674)
+
+## [0.1.31] - 2026-03-04
+
+- bump (346ffc1)
+- localhost replaced by 127.0.0.1 (82b9f30)
+- .29 (587b0e1)
+- improve up down and bootstrap script (b79ebaf)
+- checksum (22c8086)
+- checksum (96b434f)
+- checksum (15ed3c0)
+- checksum (8a6543a)
+- bump embed trino linksg (8440504)
+- bump data (765ffd9)
+- bump (cb8b232)
+- broken tests (c532229)
+- release 0.1.18, preflight checks (d902249)
+- fix compute display bug (d10f5d9)
+- cleanup packer files (6330f18)
+- plan mode (cb36a8a)
+- bump to 0.1.16 - agent ui (41ac1a2)
+- bump to 0.1.15 - agent ui (4ebe2e1)
+- bump to 0.1.14 (6c3a7fa)
+- bump to 0.1.13 (8db570f)
+- release 0.1.12 (c1c79e5)
+- bump (11aa3b0)
+- git keep and bump tui (be1678e)
+- skills, index, rrf, compacted context (100k > 10k) (7b2fffd)
+- cloudflare and token consumption, graphs indexing (0ad9eec)
+- bump storage default (22c83ba)
+- storage fix (68a22a0)
+- skills update (7f56500)
+- v9 bump (3864446)
+- bump (c95eedc)
+- rrf (dbf8c95)
+- feat: warning when running predictions (95e8c52)
+- feat: support for local predictions (45cf26b)
+- feat: wip support for predictions + mlflow (3457052)
+- add Reciprocal Rank Fusion (RRF) to knowledge and skill retrieval (61549bc)
+- validate CSV headers in compute_run readiness check (a8c7a43)
+- fix corrupted Iceberg metadata: probe tables + force cleanup on re-apply (50578af)
+- enforce: never use foundation_apply to fix broken products (2e049bf)
+- update SKILL.md with complete tool reference for knowledge retrieval (30b1924)
+- add storage read, input DP table probe, and compute_run improvements (34e6c4c)
+- skills update (1220385)
+- skills update (bb66958)
+- some tui improvement andd tools apply overwrite (e90c35c)
+- skills update (e9227a1)
+- skills update (669c4b3)
+- fix plugin pre-flight checks (f741743)
+- increase agent context (6479aaa)
+- skills and init sql fixes (5fce35e)
+- checksum (3518b56)
+- penging job limit (a139861)
+- checksum (575d28c)
+- bump (92049ba)
+- fix bug per tab status (0a33657)
+- fix bug per tab status (50457c6)
+- checksumming (0ad842e)
+- shot af mardkwon overlapping (51f63b9)
+- add spark dockerfile for multiarch builds (95abbd1)
+- fix plugin initialization (16b9782)
+- split index.js (50902a2)
+- cloudflare cidr (cc4e021)
+- cloduflare restrictions (2f6ba2d)
+- sequential start (86b496e)
+- sequential start (4930fe1)
+- sequential start (353f014)
+- qa tests (2dc6a1a)
+- bump sha for .85 (dc2edfe)
+- preserve env on sudo (7831227)
+- bump sha for .84 (6c052f9)
+- non interactive for azure vms (0aa8a2f)
+- keep .env if present (d072450)
+- bump (7a8e732)
+- ensure opa is on compose if not set (f4a5228)
+- checksum bump (a2ccc20)
+- netrc defensive checks (a0b0ccc)
+- netrc defensive checks (ae37403)
+- checksum (ec45d11)
+- update sync and fix up (7f9af72)
+- expand test for azure and add new per app tag support (388a168)
+- checksum on update (44005fc)
+- cleanup for later (15e5313)
+- cleanup for later (11c9597)
+- switch branch feature (822fecc)
+- add pull (d1c19ab)
+- Bump hono from 4.11.9 to 4.12.0 in /operator-cli (ad25144)
+- tests (f180a9a)
+- cleanup (39c49a3)
+- registry (7b7126a)
+- reconcile kafka (832d0db)
+- gh login bug (025886c)
+- cleanup (bb96cab)
+- strip envs from process (2421180)
+- force use of gh creds not tokens in envs var (fff7787)
+- resolve import between npm installs and npm link (79522e1)
+- fix gh scope and azure states (afd846c)
+- refactoring (da50352)
+- split fops repo (d447638)
+- aks (b791f8f)
+- refactor azure (67d3bad)
+- wildcard (391f023)
+- azure plugin (c074074)
+- zap (d7e6e7f)
+- fix knock (cf89c05)
+- azure (4adec98)
+- Bump tar from 7.5.7 to 7.5.9 in /operator-cli (e41e98e)
+- azure stack index.js split (de12272)
+- Bump ajv from 8.17.1 to 8.18.0 in /operator-cli (76da21f)
+- packer (9665fbc)
+- remove stack api (db0fd4d)
+- packer cleanup (fe1bf14)
+- force refresh token (3a3d7e2)
+- provision shell (2ad505f)
+- azure vm management (91dcb31)
+- azure specific (2b0cca8)
+- azure packer (12175b8)
+- init hashed pwd (db8523c)
+- packer (5b5c7c4)
+- doctor for azure vm (ed524fa)
+- packer and 1pwd (c6d053e)
+- split big index.js (dc85a1b)
+- kafka volume update (21815ec)
+- fix openai azure tools confirmation and flow (0118cd1)
+- nighly fixx, test fix (5e0d04f)
+- open ai training (cdc494a)
+- openai integration in azure (1ca1475)
+- ci (672cea9)
+- refresh ghcr creds (4220c48)
+- cleaned up version (1a0074f)
+- traefik on ghcr and templates (8e31a05)
+- apply fcl (e78911f)
+- demo landscape (dd205fe)
+- smarter login and schema (1af514f)
+- no down before up unless something broke (56b1132)
+- dai, reconcile failed containers (12907fa)
+- reconcile dead container (7da75e4)
+- defensive around storage buckets dir (b98871d)
+- defensive around storage buckets dir (e86e132)
+- gear in for multiarch (bf3fa3e)
+- up autofix (99c7f89)
+- autofix stale containers on up (43c7d0f)
+- shared sessions fix (5de1359)
+- share sessions between ui and tui (8321391)
+- fix chat view display details (e263996)
+- fix chat view display details (9babdda)
+- tui up fixes (86e9f17)
+- fix commands init (442538b)
+- enable k3s profile (b2dcfc8)
+- test up till job creation (656d388)
+- tui fixes (0599779)
+- cleanup (27731f0)
+- train (90bf559)
+- training (f809bf6)
+- training (ba2b836)
+- training (6fc5267)
+- training (4af8ac9)
+- fix build script (bd82836)
+- infra test (5b79815)
+- infra test (3a0ac05)
+- infra test (e5c67b5)
+- tests (ae7b621)
+- tests (c09ae6a)
+- update tui (4784153)
+- training (0a5a330)
+- tui (df4dd4a)
+- pkg builds (4dc9993)
+- also source env for creds (9a17d8f)
+- fcl support (e8a5743)
+- fcl support (8d6b6cd)
+- fcl support (cb76a4a)
+- bump package (df2ee85)
+- add iam mgmt (2d3c294)
+- fix k3s (976ae77)
+- fix trino, add storage plugin (75cb1f4)
+- add project root as config (a2863c6)
+- failure learnings (637ef5c)
+- Apple signed binaries (63a610e)
+- send build info to apple for notary service (300c220)
+- migration failure fixes (c7f0b2f)
+- release to wipe clean pg on duplicate key error (a38bf4d)
+- small fix (a26a674)
+- cleanup (ca7405d)
+- bump packages (59723b7)
+
+# Changelog
+
+All notable changes to @meshxdata/fops (Foundation Operator CLI) are documented here.
+
 ## [0.1.30] - 2026-03-04
 
 - localhost replaced by 127.0.0.1 (82b9f30)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshxdata/fops",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "CLI to install and manage data mesh platforms",
   "keywords": [
     "fops",
@@ -46,6 +46,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "dataloader": "^2.2.3",
+    "electron": "^34.5.8",
     "execa": "^9.5.2",
     "graphql": "^16.13.0",
     "hcl2-parser": "^1.0.3",

package/src/electron/main.js

@@ -0,0 +1,24 @@
+const { app, BrowserWindow } = require("electron");
+
+const url = process.env.FOUNDATION_URL || "http://127.0.0.1:3002";
+
+function createWindow() {
+  const win = new BrowserWindow({
+    width: 1400,
+    height: 900,
+    title: "Foundation",
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+    },
+  });
+
+  win.loadURL(url);
+  win.setMenuBarVisibility(false);
+}
+
+app.whenReady().then(createWindow);
+
+app.on("window-all-closed", () => {
+  app.quit();
+});

package/src/plugins/bundled/fops-plugin-embeddings/index.js

@@ -260,6 +260,13 @@ export default {
           return 0;
         }
       },
+      async embedTexts(texts) {
+        if (!texts || texts.length === 0) return [];
+        if (!embeddingClient.isModelCached()) return [];
+        try {
+          return await embeddingClient.embed(texts);
+        } catch { return []; }
+      },
     });
 
     // NOTE: ONNX models are loaded lazily on first query, NOT eagerly at startup.

package/src/plugins/bundled/fops-plugin-foundation/index.js

@@ -254,6 +254,245 @@ export function register(api) {
           process.exit(1);
         }
       });
+
+    // ── align ─────────────────────────────────────────────────────────────
+    foundation
+      .command("align <source> [target]")
+      .description("Align source column names to target schema columns (exact → embedding → levenshtein)")
+      .option("--threshold <number>", "Similarity threshold 0–1 (default 0.7)", "0.7")
+      .option("--json", "Output raw JSON")
+      .action(async (source, target, opts) => {
+        const { alignColumns } = await import("./lib/align.js");
+        const { fetchEntityColumns } = await import("./lib/tools-write.js");
+        const { statSync, readdirSync, readFileSync } = await import("node:fs");
+        const threshold = Number.parseFloat(opts.threshold) || 0.7;
+
+        // Resolve source columns — directory of CSVs, comma-separated names, or entity identifier
+        const isDirectory = (s) => { try { return statSync(s).isDirectory(); } catch { return false; } };
+        const isIdentifier = (s) => s && !/,/.test(s) && !/\s/.test(s.trim());
+
+        let sourceCols;
+        if (isDirectory(source)) {
+          const csvFiles = readdirSync(source).filter((f) => /\.csv$/i.test(f));
+          if (csvFiles.length === 0) {
+            console.error(ERR(`  ✗ No CSV files found in: ${source}`));
+            process.exit(1);
+          }
+          const seen = new Set();
+          for (const file of csvFiles) {
+            try {
+              const firstLine = readFileSync(path.join(source, file), "utf8").split("\n")[0]?.trim();
+              if (!firstLine) continue;
+              for (const col of firstLine.split(",").map((c) => c.trim().replace(/^["']|["']$/g, ""))) {
+                if (col) seen.add(col);
+              }
+            } catch { /* skip unreadable file */ }
+          }
+          sourceCols = [...seen];
+          console.log(DIM(`  Reading ${csvFiles.length} CSV file(s) from ${source} — ${sourceCols.length} unique columns`));
+        } else if (isIdentifier(source)) {
+          sourceCols = await fetchEntityColumns(client, source.trim(), "data_object");
+        } else {
+          sourceCols = source.split(",").map((c) => c.trim()).filter(Boolean);
+        }
+        if (!sourceCols || sourceCols.length === 0) {
+          console.error(ERR(`  ✗ Could not resolve source columns from: ${source}`));
+          process.exit(1);
+        }
+
+        // Get embeddings service (used for both target inference and column alignment)
+        let embSvc;
+        try {
+          embSvc = typeof api.getService === "function" ? api.getService("embeddings:search") : null;
+        } catch { /* embeddings not available */ }
+        const embedTexts = embSvc?.embedTexts ? embSvc.embedTexts.bind(embSvc) : null;
+
+        // Resolve target — explicit arg, or auto-infer from landscape
+        let targetCols;
+        let resolvedTarget = target;
+        if (!target) {
+          // Try embedding search first: query = unique source column names joined
+          const query = sourceCols.join(" ");
+          let dpIdentifier = null;
+          let dpName = null;
+          if (embSvc?.search && embSvc.hasEntries("landscape")) {
+            try {
+              const hits = await embSvc.search(query, { topK: 10, source: "landscape" });
+              const dpHit = hits.find((h) => h.metadata?.entityType === "data_product");
+              if (dpHit) {
+                dpIdentifier = dpHit.metadata.identifier;
+                dpName = dpHit.title?.replace(/^product\//, "") || dpIdentifier;
+              }
+            } catch { /* fall through */ }
+          }
+          // Fallback: list all data products, auto-select if only one
+          if (!dpIdentifier) {
+            try {
+              const res = await client.get("/data/data_product/list?per_page=100");
+              const products = res?.data || res?.items || res || [];
+              if (products.length === 1) {
+                dpIdentifier = products[0].identifier;
+                dpName = products[0].name || dpIdentifier;
+              } else if (products.length > 1) {
+                console.error(ERR("  ✗ Multiple data products found — specify a target:"));
+                for (const p of products) console.error(DIM(`    ${p.identifier}  ${p.name || ""}`));
+                process.exit(1);
+              } else {
+                console.error(ERR("  ✗ No data products found in the landscape. Specify a target explicitly."));
+                process.exit(1);
+              }
+            } catch (e) {
+              console.error(ERR(`  ✗ Could not list data products: ${e.message}`));
+              process.exit(1);
+            }
+          }
+          console.log(DIM(`  Auto-selected target: ${dpName} (${dpIdentifier})`));
+          resolvedTarget = dpIdentifier;
+          targetCols = await fetchEntityColumns(client, dpIdentifier, "data_product");
+        } else if (isIdentifier(target)) {
+          targetCols = await fetchEntityColumns(client, target.trim(), "data_product");
+        } else {
+          targetCols = target.split(",").map((c) => c.trim()).filter(Boolean);
+        }
+        if (!targetCols || targetCols.length === 0) {
+          console.error(ERR(`  ✗ Could not resolve target columns from: ${resolvedTarget}`));
+          process.exit(1);
+        }
+
+        const result = await alignColumns(sourceCols, targetCols, { embedTexts, threshold });
+
+        if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        // Formatted table output
+        const title = `Column Alignment: ${source} → ${resolvedTarget}`;
+        banner(title);
+        console.log();
+
+        if (result.mappings.length === 0) {
+          console.log(WARN("  No mappings found above threshold."));
+        } else {
+          const COL_W = 20, EXP_W = 24, MET_W = 12;
+          console.log(DIM(`  ${"Source".padEnd(COL_W)}  ${"Expected".padEnd(EXP_W)}  ${"Method".padEnd(MET_W)}  Confidence`));
+          console.log(DIM("  " + "─".repeat(COL_W + EXP_W + MET_W + 20)));
+          for (const m of result.mappings) {
+            const conf = `${Math.round(m.confidence * 100)}%`;
+            const methodColor = m.method === "exact" ? OK : m.method === "embedding" ? ACCENT : WARN;
+            console.log(
+              `  ${m.sourceColumn.slice(0, COL_W - 1).padEnd(COL_W)}  ${m.expectedColumn.slice(0, EXP_W - 1).padEnd(EXP_W)}  ${methodColor(m.method.padEnd(MET_W))}  ${conf}`,
+            );
+          }
+        }
+
+        if (result.unmappedSource.length > 0) {
+          console.log(WARN(`\n  Unmapped source:   ${result.unmappedSource.join(", ")}`));
+        }
+        if (result.unmappedExpected.length > 0) {
+          console.log(WARN(`  Unmapped expected: ${result.unmappedExpected.join(", ")}`));
+        }
+
+        if (result.suggestedTransformation) {
+          console.log(ACCENT("\n  Suggested rename_column step:"));
+          console.log(`  ${JSON.stringify(result.suggestedTransformation.mapping, null, 2).replace(/\n/g, "\n  ")}`);
+        }
+        console.log();
+      });
+
+    // ── run ───────────────────────────────────────────────────────────────────
+    foundation
+      .command("run")
+      .description("Open the Foundation UI in an Electron window")
+      .option("--url <url>", "Override the frontend URL")
+      .action(async (opts) => {
+        const { createRequire } = await import("node:module");
+        const { spawn } = await import("node:child_process");
+        const { readFileSync } = await import("node:fs");
+        const { findComposeRoot } = await import("./lib/tools-write.js");
+
+        // Resolve frontend URL: flag → env → .env file → default
+        let frontendUrl = opts.url || process.env.FOUNDATION_PUBLIC_URL;
+        if (!frontendUrl) {
+          const root = program._fopsRoot || findComposeRoot();
+          if (root) {
+            try {
+              const envContent = readFileSync(`${root}/.env`, "utf8");
+              const m = envContent.match(/^FOUNDATION_PUBLIC_URL=(.+)$/m);
+              if (m) frontendUrl = m[1].trim();
+            } catch { /* .env not found */ }
+          }
+        }
+        frontendUrl = frontendUrl || "http://127.0.0.1:3002";
+
+        // Resolve electron binary + fops root (via realpathSync to follow node_modules symlink)
+        const { writeFileSync, realpathSync } = await import("node:fs");
+        const { tmpdir } = await import("node:os");
+        const { join, resolve, dirname } = await import("node:path");
+
+        let electronBin;
+        let iconPath;
+        try {
+          const req = createRequire(import.meta.url);
+          electronBin = req("electron");
+          // Resolve real path of electron pkg to find the fops install root
+          const realElectronPkg = realpathSync(req.resolve("electron/package.json"));
+          const fopsRoot = resolve(dirname(realElectronPkg), "../..");
+          iconPath = join(fopsRoot, "src/electron/icon.png");
+        } catch {
+          console.error(ERR("  ✗ Electron is not installed. Run: npm install -g electron"));
+          process.exit(1);
+        }
+
+        // Write main script to a temp file — the plugin runs from ~/.fops/plugins/
+        // so relative path resolution from import.meta.url is not reliable
+        const mainScript = join(tmpdir(), "fops-electron-main.js");
+        writeFileSync(mainScript, `
+const { app, BrowserWindow, nativeImage } = require("electron");
+const url = process.env.FOUNDATION_URL || "http://127.0.0.1:3002";
+const iconPath = process.env.FOUNDATION_ICON;
+
+// Enable macOS platform authenticator (passkeys + TouchID)
+app.commandLine.appendSwitch("enable-features", "WebAuthenticationTouchId,WebAuthenticationCable");
+
+app.whenReady().then(() => {
+  if (iconPath) {
+    try {
+      const icon = nativeImage.createFromPath(iconPath);
+      if (process.platform === "darwin") app.dock.setIcon(icon);
+    } catch {}
+  }
+
+  const win = new BrowserWindow({
+    width: 1400, height: 900, title: "Foundation",
+    icon: iconPath || undefined,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+    },
+  });
+
+  // Allow Google OAuth and other auth popups to open
+  win.webContents.setWindowOpenHandler(({ url: popupUrl }) => {
+    return { action: "allow" };
+  });
+
+  win.loadURL(url);
+  win.setMenuBarVisibility(false);
+});
+
+app.on("window-all-closed", () => app.quit());
+`);
+
+        console.log(ACCENT(`  Opening Foundation at ${frontendUrl}`));
+
+        const child = spawn(electronBin, [mainScript], {
+          stdio: "ignore",
+          env: { ...process.env, FOUNDATION_URL: frontendUrl, FOUNDATION_ICON: iconPath || "" },
+          detached: true,
+        });
+        child.unref();
+      });
   });
 
   // ─── Landscape cache state (used by tools + service) ────────────────────
@@ -479,6 +718,7 @@ foundation_entity is only for: SQL query action, or if foundation_graphql return
       "foundation_iam",
       "foundation_iam_manage",
       "foundation_graphql",
+      "foundation_align",
       "memory",
     ],
     maxIterations: resolveFoundationMaxIterations(),

package/src/plugins/bundled/fops-plugin-foundation/lib/align.js

@@ -0,0 +1,145 @@
+/**
+ * Column alignment: maps source CSV column names to expected schema column names.
+ * Three-pass: exact → embedding (if model available) → Levenshtein ratio fallback.
+ */
+
+export function normalizeColName(s) {
+  return String(s || "")
+    .toLowerCase()
+    .replace(/\s+/g, "_")
+    .replace(/[^a-z0-9_]/g, "");
+}
+
+function cosineSimilarity(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+function levenshteinRatio(a, b) {
+  const x = String(a || "");
+  const y = String(b || "");
+  if (x === y) return 1;
+  const m = x.length, n = y.length;
+  if (m === 0 || n === 0) return 0;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = x[i - 1] === y[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return 1 - dp[m][n] / Math.max(m, n);
+}
+
+/**
+ * Align source column names to expected column names using three passes.
+ *
+ * @param {string[]} sourceColumns
+ * @param {string[]} expectedColumns
+ * @param {{ embedTexts?: Function, threshold?: number }} opts
+ * @returns {Promise<{ mappings, unmappedSource, unmappedExpected, suggestedTransformation? }>}
+ */
+export async function alignColumns(sourceColumns, expectedColumns, { embedTexts, threshold = 0.7 } = {}) {
+  const mappings = [];
+  const unmappedSrc = new Set(sourceColumns);
+  const unmappedExp = new Set(expectedColumns);
+
+  // Pass 1 — Exact (normalized)
+  for (const src of sourceColumns) {
+    const normSrc = normalizeColName(src);
+    for (const exp of [...unmappedExp]) {
+      if (normalizeColName(exp) === normSrc) {
+        mappings.push({ sourceColumn: src, expectedColumn: exp, confidence: 1.0, method: "exact" });
+        unmappedSrc.delete(src);
+        unmappedExp.delete(exp);
+        break;
+      }
+    }
+  }
+
+  // Pass 2 — Embedding (if embedTexts provided)
+  if (typeof embedTexts === "function" && unmappedSrc.size > 0 && unmappedExp.size > 0) {
+    try {
+      const srcList = [...unmappedSrc];
+      const expList = [...unmappedExp];
+      const toHuman = (s) => normalizeColName(s).replace(/_/g, " ");
+      const srcTexts = srcList.map(toHuman);
+      const expTexts = expList.map(toHuman);
+
+      const allVecs = await embedTexts([...srcTexts, ...expTexts]);
+      if (allVecs && allVecs.length === srcTexts.length + expTexts.length) {
+        const srcVecs = allVecs.slice(0, srcTexts.length);
+        const expVecs = allVecs.slice(srcTexts.length);
+
+        // Build score matrix and collect all pairs above threshold
+        const candidates = [];
+        for (let i = 0; i < srcList.length; i++) {
+          for (let j = 0; j < expList.length; j++) {
+            const score = cosineSimilarity(srcVecs[i], expVecs[j]);
+            if (score >= threshold) candidates.push({ i, j, score });
+          }
+        }
+        // Greedy assign highest-confidence pairs first
+        candidates.sort((a, b) => b.score - a.score);
+        const usedSrc = new Set(), usedExp = new Set();
+        for (const { i, j, score } of candidates) {
+          if (usedSrc.has(i) || usedExp.has(j)) continue;
+          usedSrc.add(i);
+          usedExp.add(j);
+          mappings.push({ sourceColumn: srcList[i], expectedColumn: expList[j], confidence: score, method: "embedding" });
+          unmappedSrc.delete(srcList[i]);
+          unmappedExp.delete(expList[j]);
+        }
+      }
+    } catch { /* model not ready — fall through to pass 3 */ }
+  }
+
+  // Pass 3 — Levenshtein ratio fallback
+  if (unmappedSrc.size > 0 && unmappedExp.size > 0) {
+    const srcList = [...unmappedSrc];
+    const expList = [...unmappedExp];
+    const candidates = [];
+    for (const src of srcList) {
+      for (const exp of expList) {
+        const score = levenshteinRatio(normalizeColName(src), normalizeColName(exp));
+        if (score >= threshold) candidates.push({ src, exp, score });
+      }
+    }
+    candidates.sort((a, b) => b.score - a.score);
+    const usedSrc = new Set(), usedExp = new Set();
+    for (const { src, exp, score } of candidates) {
+      if (usedSrc.has(src) || usedExp.has(exp)) continue;
+      usedSrc.add(src);
+      usedExp.add(exp);
+      mappings.push({ sourceColumn: src, expectedColumn: exp, confidence: score, method: "levenshtein" });
+      unmappedSrc.delete(src);
+      unmappedExp.delete(exp);
+    }
+  }
+
+  const result = {
+    mappings,
+    unmappedSource: [...unmappedSrc],
+    unmappedExpected: [...unmappedExp],
+  };
+
+  if (mappings.length > 0) {
+    const renameMapping = {};
+    for (const { sourceColumn, expectedColumn } of mappings) {
+      if (sourceColumn !== expectedColumn) renameMapping[sourceColumn] = expectedColumn;
+    }
+    if (Object.keys(renameMapping).length > 0) {
+      result.suggestedTransformation = { transform: "rename_column", mapping: renameMapping };
+    }
+  }
+
+  return result;
+}

package/src/plugins/bundled/fops-plugin-foundation/lib/client.js

@@ -5,6 +5,8 @@ import path from "node:path";
 
 const DEFAULT_BASE_URL = "http://127.0.0.1:9001/api";
 const TOKEN_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const RETRY_COUNT = 3;
+const RETRY_DELAY_MS = 10_000;
 
 /** Resolve API base URL: config.apiUrl, FOUNDATION_API_URL, or default. Ensures path ends with /api. */
 function resolveBaseUrl(config) {
@@ -18,6 +20,18 @@ function resolveBaseUrl(config) {
   return url.endsWith("/api") ? url : `${url}/api`;
 }
 
+/** Resolve x-org header value: config.orgId, ORG_ID env, ORG_NAME env, root .env, or "root". */
+function resolveOrgId(config, rootEnv = {}) {
+  return (
+    config?.orgId?.trim() ||
+    process.env.ORG_ID?.trim() ||
+    rootEnv.ORG_ID?.trim() ||
+    process.env.ORG_NAME?.trim() ||
+    rootEnv.ORG_NAME?.trim() ||
+    "root"
+  );
+}
+
 function isValidJwt(token) {
   if (!token) return false;
   const parts = token.split(".");
@@ -47,7 +61,6 @@ function request(method, url, headers = {}, body, timeoutMs = 15_000) {
       method,
       headers: {
         "Content-Type": "application/json",
-        "x-org": "root",
         ...headers,
       },
       timeout: timeoutMs,
@@ -73,6 +86,28 @@ function request(method, url, headers = {}, body, timeoutMs = 15_000) {
   });
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** Like request() but retries on network errors and 5xx responses. */
+async function requestWithRetries(method, url, headers, body, timeoutMs, maxRetries = RETRY_COUNT, delayMs = RETRY_DELAY_MS) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    let res;
+    try {
+      res = await request(method, url, headers, body, timeoutMs);
+    } catch (e) {
+      if (attempt < maxRetries) { await sleep(delayMs); continue; }
+      throw new Error(`Request failed after ${maxRetries} attempts: ${e.message}`);
+    }
+    if (res.status >= 500 && attempt < maxRetries) {
+      await sleep(delayMs);
+      continue;
+    }
+    return res;
+  }
+}
+
 /**
  * Like request() but returns response headers, does NOT follow redirects,
  * and supports both JSON and url-encoded bodies.
@@ -251,6 +286,7 @@ export class FoundationClient {
   constructor(config = {}, opts = {}) {
     this._config = { ...config };
     this._baseUrl = resolveBaseUrl(config);
+    this._org = resolveOrgId(config, loadRootProjectEnv());
     this._getCredentials = opts.getCredentials || null;
     this._token = null;
     this._tokenExpiry = 0;
@@ -501,7 +537,7 @@ export class FoundationClient {
    */
   async _request(method, apiPath, body) {
     const url = apiPath.startsWith("http") ? apiPath : `${this._baseUrl}${apiPath}`;
-    const headers = {};
+    const headers = { "x-org": this._org };
 
     await this.ensureAuth();
     headers.Authorization = `Bearer ${this._token}`;
@@ -526,7 +562,7 @@ export class FoundationClient {
       headers["CF-Access-Client-Secret"] = cfSecret;
     }
 
-    let res = await request(method, url, headers, body, this._timeoutMs);
+    let res = await requestWithRetries(method, url, headers, body, this._timeoutMs);
 
     if (res.status === 401) {
       this._token = null;
@@ -537,7 +573,7 @@ export class FoundationClient {
       headers.Authorization = `Bearer ${this._token}`;
       if (this._cfJwt) headers.Cookie = `CF_Authorization=${this._cfJwt}`;
       else delete headers.Cookie;
-      res = await request(method, url, headers, body, this._timeoutMs);
+      res = await requestWithRetries(method, url, headers, body, this._timeoutMs);
     }
 
     if (res.status >= 400) {

package/src/plugins/bundled/fops-plugin-foundation/lib/tools-write.js

@@ -2440,6 +2440,52 @@ export function registerWriteTools(api, client) {
         return `Unknown scope: ${raw.scope}`;
       },
     },
+    // foundation_align
+    {
+      name: "foundation_align",
+      description: "Align source CSV column names to expected schema column names using exact, embedding, and Levenshtein matching. Returns mappings and a ready-to-use rename_column transformation.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          source_columns: { type: "array", items: { type: "string" }, description: "Raw source column names (e.g. from a CSV header)" },
+          expected_columns: { type: "array", items: { type: "string" }, description: "Target schema column names (e.g. from a data product schema)" },
+          source_identifier: { type: "string", description: "Entity identifier to fetch source columns from (data_object or data_product)" },
+          target_identifier: { type: "string", description: "Entity identifier to fetch expected columns from (data_object or data_product)" },
+          threshold: { type: "number", description: "Minimum similarity score 0–1 (default 0.7)" },
+        },
+      },
+      async execute(input) {
+        const { alignColumns } = await import("./align.js");
+        let sourceCols = input.source_columns;
+        let expectedCols = input.expected_columns;
+
+        if (!sourceCols && input.source_identifier) {
+          const cols = await fetchEntityColumns(client, input.source_identifier, "data_object");
+          if (!cols) return `Error: could not fetch columns for source identifier "${input.source_identifier}"`;
+          sourceCols = cols;
+        }
+        if (!expectedCols && input.target_identifier) {
+          const cols = await fetchEntityColumns(client, input.target_identifier, "data_product");
+          if (!cols) return `Error: could not fetch columns for target identifier "${input.target_identifier}"`;
+          expectedCols = cols;
+        }
+
+        if (!sourceCols || sourceCols.length === 0) return "Error: source_columns or source_identifier required";
+        if (!expectedCols || expectedCols.length === 0) return "Error: expected_columns or target_identifier required";
+
+        let embedTexts;
+        try {
+          const embSvc = typeof api.getService === "function" && api.getService("embeddings:search");
+          if (embSvc?.embedTexts) embedTexts = embSvc.embedTexts.bind(embSvc);
+        } catch { /* embeddings not available */ }
+
+        const result = await alignColumns(sourceCols, expectedCols, {
+          embedTexts,
+          threshold: typeof input.threshold === "number" ? input.threshold : 0.7,
+        });
+        return fmt(result);
+      },
+    },
   ];
 
   return tools;

package/src/ui/tui/App.js

@@ -2904,12 +2904,17 @@ export async function launchTui(root, registry, opts = {}) {
       }
     }
   };
+  // Catch-all for mouse-move position reports that some Windows/ConPTY
+  // terminals emit in non-standard formats (e.g. CSI with lowercase 'm',
+  // extra semicolons, or raw coordinate bytes after CSI).
+  const CATCHALL_MOUSE_RE = /\x1b\[<?\d+;\d+;\d+[mM]/g;
   const stripMouseSequences = (str) => {
     // Strip all complete mouse sequences, returning any remaining text
     return str
       .replace(SGR_MOUSE_RE, "")
       .replace(CSI_MOUSE_RE, "")
-      .replace(LEGACY_MOUSE_RE, "");
+      .replace(LEGACY_MOUSE_RE, "")
+      .replace(CATCHALL_MOUSE_RE, "");
   };
   const origStdinEmit = process.stdin.emit.bind(process.stdin);
   process.stdin.emit = function (event, ...args) {
@@ -3118,10 +3123,13 @@ export async function launchTui(root, registry, opts = {}) {
   // small escape sequences during idle).
   // \x1b[?1000h = click/wheel tracking (basic compatibility; helps on some Windows terminals)
   // \x1b[?1002h = button-event tracking (press, release, wheel)
-  // \x1b[?1003h = any-event tracking (fallback when 1002 is unreliable)
   // \x1b[?1006h = SGR extended mode (scroll wheel as button 64/65)
-  // \x1b[?1015h = CSI decimal mouse mode (fallback parser enabled above)
-  const MOUSE_ENABLE = "\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h\x1b[?1015h";
+  // NOTE: ?1003h (any-event/move tracking) deliberately omitted — it floods
+  // stdin with mouse-position reports on every cursor move.  Windows SSH
+  // terminals (Windows Terminal, PuTTY, ConPTY) often send these in formats
+  // the strip regex cannot match, causing raw escape codes to appear in the
+  // input box.  ?1015h (URXVT decimal mode) also omitted for similar reasons.
+  const MOUSE_ENABLE = "\x1b[?1000h\x1b[?1002h\x1b[?1006h";
   origStdoutWrite(MOUSE_ENABLE);
   // Re-assert mouse tracking every 5s in case a render or resize resets modes
   const mouseTimerId = setInterval(() => origStdoutWrite(MOUSE_ENABLE), 5000);
@@ -3155,7 +3163,7 @@ export async function launchTui(root, registry, opts = {}) {
     // Clear the full-screen content, restore terminal state
     process.stdout.write(
       "\x1b[2J\x1b[H"               // clear screen, cursor to 1,1
-      + "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l" // disable all mouse tracking modes
+      + "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l" // disable all mouse tracking modes (include 1003/1015 in case previously enabled)
       + "\x1b[?25h"                   // show cursor
       + "\x1b[0m"                     // reset attributes
     );