@montytools/cli 0.5.2 → 0.5.4

package/bin/monty.mjs

@@ -18,6 +18,7 @@ import { CATALOG, REGISTRIES } from "./catalog.mjs";
 import { CompileError, compileAppConfig } from "../lib/compile.mjs";
 import { manifestHash } from "../lib/schemaCodegen.mjs";
 import { readSchemaState, schemaPull, writeSchemaState } from "../lib/schemaPull.mjs";
+import { mergeViewConfig, normalizeViewFilters, parseHiddenColumns, parseViewSort, validateViewColumns } from "../lib/views.mjs";
 
 // MONTY_HOME overrides the state root (default ~/.monty): config.json,
 // apps/, and desktop.json all live under it. This is how a second, isolated
@@ -675,6 +676,12 @@ tables (zod), derived fields (\`rollup\`/\`lookup\`/\`formula\`), \`metrics\`,
 - Formulas are strings in the Monty expression grammar, e.g.
   \`formula(montyMoney(), "monthlySales * commissionRate")\` — fields declared
   ABOVE the formula and \`metrics.<name>\` are in scope.
+- A filtered or sorted slice of one table is a shared saved view. Use
+  \`monty views set <table> <name> ...\` before adding custom code. A custom
+  page is for interactions, multi-table layouts, or visualizations that a
+  system record page cannot express. If the page is still one table, start
+  with \`RecordPage\` from \`@montytools/sdk/react\` and add typed actions
+  with the record controls from \`@montytools/sdk/ui\`.
 - Need a bespoke page later? \`monty add page\` declares it and upgrades this
   app with a SPA scaffold; \`monty save\` ships the code.
 `;
@@ -984,7 +991,7 @@ async function freePort(start) {
 // Apps pin @montytools/sdk at scaffold time and go stale — the CLI knows the
 // minimum SDK its workflows need (e.g. tunnel-host allowlisting lives in the
 // SDK's vite plugin) and upgrades the app automatically before dev/deploy.
-const MIN_SDK = "0.2.2";
+const MIN_SDK = "0.2.4";
 const SDK_VITE_CACHE_STAMP = "sdk-vite-cache-version";
 
 function installedSdkVersion(appDir) {
@@ -1312,7 +1319,7 @@ async function performTakeover(appDir, s) {
     spawnSync("taskkill", ["/pid", String(s.pid), "/T", "/F"], { stdio: "ignore" });
     if (Number.isInteger(s.vitePid)) spawnSync("taskkill", ["/pid", String(s.vitePid), "/T", "/F"], { stdio: "ignore" });
   } else if (!signalPid(s.pid, "SIGTERM")) {
-    fail("TAKEOVER_FAILED", `The running session (pid ${s.pid}) belongs to another user. Stop it manually, then rerun \`monty dev\`.`);
+    fail("TAKEOVER_FAILED", `The running session (pid ${s.pid}) belongs to another user. Stop it from the terminal or Desktop instance that started it, then rerun \`monty dev\`. If that owner is unavailable, check \`monty support status\` and submit the incident when sharing is enabled.`);
   }
   let ok = await waitGone(TAKEOVER_WAIT_MS);
   if (!ok && process.platform !== "win32") {
@@ -2920,9 +2927,9 @@ function resolveDataApp() {
 
 // mk_ key → { convexUrl, token }. The token is workspace-scoped and expires
 // in 5 minutes — minted fresh per invocation, never stored.
-async function dataAuth() {
+async function workspaceAuth() {
   const { host, key } = loadConfig();
-  if (!key) fail("NOT_LOGGED_IN", `Reading and writing app data needs your workspace (${host}). Run \`monty login\` first.`);
+  if (!key) fail("NOT_LOGGED_IN", `This command needs your workspace (${host}). Run \`monty login\` first.`);
   let convexUrl = null;
   try {
     convexUrl = (await fetch(`${host}/api/config`).then((r) => r.json()))?.convexUrl;
@@ -2943,13 +2950,13 @@ async function dataAuth() {
 // app data is JSON by construction, no convex encoding needed). ConvexError
 // payloads carry { code, fix } and surface verbatim: errors stay
 // instructions in the terminal the agent is watching.
-async function callRecords(kind, fn, args, auth) {
+async function callConvex(kind, path, args, auth) {
   let body = null;
   try {
     const r = await fetch(`${auth.convexUrl}/api/${kind}`, {
       method: "POST",
       headers: { "content-type": "application/json", authorization: `Bearer ${auth.token}` },
-      body: JSON.stringify({ path: `records:${fn}`, args, format: "json" }),
+      body: JSON.stringify({ path, args, format: "json" }),
     });
     body = await r.json().catch(() => null);
   } catch { /* handled below */ }
@@ -2962,6 +2969,10 @@ async function callRecords(kind, fn, args, auth) {
   return body.value;
 }
 
+async function callRecords(kind, fn, args, auth) {
+  return callConvex(kind, `records:${fn}`, args, auth);
+}
+
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
@@ -3101,7 +3112,7 @@ async function data() {
     const name = flag("name") ?? basename(path);
     const contentType = flag("type") ?? inferContentType(name);
     const app = resolveDataApp();
-    const auth = await dataAuth();
+    const auth = await workspaceAuth();
     if (attachFlags.length === 3) {
       // Prove the target row exists BEFORE storing bytes — a failed attach
       // after the upload would orphan the file.
@@ -3130,7 +3141,7 @@ async function data() {
     const fileId = table;
     if (!fileId) fail("MISSING_ID", "Usage: monty data download <file-id> [--out path] — ids come from a row's file field (its `id` key).");
     const app = resolveDataApp();
-    const auth = await dataAuth();
+    const auth = await workspaceAuth();
     const res = await callFiles("GET", { id: fileId }, auth, app);
     const disposition = res.headers.get("content-disposition") ?? "";
     const remoteName = /filename="([^"]+)"/.exec(disposition)?.[1] ?? fileId;
@@ -3156,7 +3167,7 @@ async function data() {
   if (!table) fail("MISSING_TABLE", `\`monty data ${verb}\` needs a table name: monty data ${verb} <table> … (\`monty data schema\` lists tables).`);
 
   const app = resolveDataApp();
-  const auth = await dataAuth();
+  const auth = await workspaceAuth();
 
   switch (verb) {
     case "list": {
@@ -3250,12 +3261,373 @@ async function data() {
   }
 }
 
+// ── monty views ────────────────────────────────────────────────────────────
+// Shared saved views are shell state, not app code. Agents manage them
+// through the same workspace-scoped platform functions the record page uses.
+// The CLI accepts concise filters, then stores the shell's existing
+// { filters, sort, hidden } ViewConfig shape unchanged.
+
+const VIEW_VALUE_FLAGS = new Set(["app", "filter", "sort", "hide", "name"]);
+
+function viewPositionals() {
+  const out = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg.startsWith("--")) {
+      if (VIEW_VALUE_FLAGS.has(arg.slice(2))) i++;
+      continue;
+    }
+    out.push(arg);
+  }
+  return out;
+}
+
+function viewsUsage() {
+  console.log("usage: monty views <list|set|update|remove> <table> [name] [flags]");
+  console.log("  list   <table> [--app slug]");
+  console.log("  set    <table> <name> [--filter '<json>'] [--sort field:asc|desc] [--hide field,...] [--app slug]");
+  console.log("  update <table> <name> [--name new-name] [--filter '<json>'] [--sort field:asc|desc|none] [--hide field,...] [--app slug]");
+  console.log("  remove <table> <name> [--app slug]");
+  console.log("filter values: null = empty; scalar = exact; array = any listed value; {\"contains\":\"text\"}; {\"min\":0,\"max\":100}");
+  console.log("example: monty views set leads \"Evaluate\" --filter '{\"pipelineId\":null}'");
+  process.exit(1);
+}
+
+function validateViewFlagValues() {
+  for (const name of VIEW_VALUE_FLAGS) {
+    const index = rest.indexOf(`--${name}`);
+    if (index >= 0 && (rest[index + 1] === undefined || rest[index + 1].startsWith("--"))) {
+      fail("MISSING_FLAG_VALUE", `--${name} needs a value.`);
+    }
+  }
+}
+
+function viewName(input) {
+  const name = input?.trim() ?? "";
+  if (name === "" || name.length > 60) {
+    fail("BAD_VIEW_NAME", "A saved view name must be 1–60 characters.");
+  }
+  return name;
+}
+
+async function viewContext(table) {
+  const app = resolveDataApp();
+  const auth = await workspaceAuth();
+  const manifest = await callConvex("query", "platform:appManifest", { slug: app }, auth);
+  if (!manifest) {
+    fail("NO_MANIFEST", `App "${app}" has no stored manifest, so it has no system table views.`);
+  }
+  const tableSpec = manifest.tables?.[table];
+  if (!tableSpec) {
+    fail("NO_SUCH_TABLE", `App "${app}" has no table "${table}". Tables: ${Object.keys(manifest.tables ?? {}).join(", ") || "(none)"}.`);
+  }
+  const declaredPages = Object.values(manifest.pages ?? {});
+  const hasTableView =
+    declaredPages.length === 0 ||
+    declaredPages.some((page) => page?.kind === "view" && page.table === table);
+  if (!hasTableView) {
+    fail("NO_TABLE_VIEW", `Table "${table}" is not shown by a system record page. Add a { kind: "view", table: "${table}" } page through \`monty schema\`, then save the view.`);
+  }
+  return {
+    app,
+    auth,
+    fields: Object.keys(tableSpec.fields ?? {}),
+  };
+}
+
+function requestedViewConfig(fields) {
+  let config;
+  try {
+    config = {
+      filters: normalizeViewFilters(parseJsonFlag("filter")),
+      sort: parseViewSort(flag("sort")),
+      hidden: parseHiddenColumns(flag("hide")),
+    };
+    return validateViewColumns(config, fields);
+  } catch (error) {
+    fail(error?.code ?? "BAD_VIEW_CONFIG", error?.fix ?? error?.message ?? "The saved view config is invalid.");
+  }
+}
+
+function requestedViewPatch() {
+  try {
+    return {
+      ...(rest.includes("--filter") ? { filters: normalizeViewFilters(parseJsonFlag("filter")) } : {}),
+      ...(rest.includes("--sort") ? { sort: parseViewSort(flag("sort")) } : {}),
+      ...(rest.includes("--hide") ? { hidden: parseHiddenColumns(flag("hide")) } : {}),
+    };
+  } catch (error) {
+    fail(error?.code ?? "BAD_VIEW_CONFIG", error?.fix ?? error?.message ?? "The saved view config is invalid.");
+  }
+}
+
+function checkedViewConfig(config, fields) {
+  try {
+    return validateViewColumns(config, fields);
+  } catch (error) {
+    fail(error?.code ?? "BAD_VIEW_CONFIG", error?.fix ?? error?.message ?? "The saved view config is invalid.");
+  }
+}
+
+async function views() {
+  validateViewFlagValues();
+  const [verb, table, rawName] = viewPositionals();
+  if (!verb || !table || rest.includes("--help") || rest.includes("-h")) viewsUsage();
+  if (!["list", "set", "update", "remove"].includes(verb)) viewsUsage();
+  const { app, auth, fields } = await viewContext(table);
+
+  if (verb === "list") {
+    const saved = await callConvex("query", "platform:savedViews", { app, page: table }, auth);
+    printJson({ app, table, views: saved });
+    return;
+  }
+
+  const name = viewName(rawName);
+  const saved = await callConvex("query", "platform:savedViews", { app, page: table }, auth);
+  const existing = saved.find((view) => view.name === name);
+
+  if (verb === "remove") {
+    if (!existing) {
+      fail("VIEW_NOT_FOUND", `No saved view named "${name}" exists for ${table}. Run \`monty views list ${table}\` to see the names.`);
+    }
+    await callConvex("mutation", "platform:deleteView", { app, page: table, name }, auth);
+    printJson({ ok: true, app, table, name, removed: true });
+    return;
+  }
+
+  if (verb === "update") {
+    if (!existing) {
+      fail("VIEW_NOT_FOUND", `No saved view named "${name}" exists for ${table}. Run \`monty views list ${table}\` to see the names.`);
+    }
+    const nextName = flag("name") === undefined ? name : viewName(flag("name"));
+    if (nextName !== name && saved.some((view) => view.name === nextName)) {
+      fail("VIEW_ALREADY_EXISTS", `A saved view named "${nextName}" already exists for ${table}. Choose another name or update that view directly.`);
+    }
+    const patch = requestedViewPatch();
+    if (nextName === name && Object.keys(patch).length === 0) {
+      fail("NO_VIEW_CHANGES", "Provide --name, --filter, --sort, or --hide. Omitted properties stay unchanged.");
+    }
+    const config = checkedViewConfig(mergeViewConfig(existing.config, patch), fields);
+    await callConvex("mutation", "platform:saveView", { app, page: table, name: nextName, config }, auth);
+    if (nextName !== name) {
+      await callConvex("mutation", "platform:deleteView", { app, page: table, name }, auth);
+    }
+    printJson({
+      ok: true,
+      app,
+      table,
+      name: nextName,
+      updated: true,
+      renamed: nextName !== name,
+      ...(nextName !== name ? { previousName: name } : {}),
+      config,
+    });
+    return;
+  }
+
+  const config = requestedViewConfig(fields);
+  await callConvex("mutation", "platform:saveView", { app, page: table, name, config }, auth);
+  printJson({ ok: true, app, table, name, created: !existing, config });
+}
+
+// ── monty support ─────────────────────────────────────────────────────────
+// Workspace admins opt in once. After that, agents may send one structured
+// report for a persistent platform failure or missing platform capability.
+// The CLI adds selected local diagnostics, but never reads source files,
+// environment variables, app records, or a raw conversation transcript.
+function supportUsage() {
+  console.log("usage: monty support <status|enable|disable|submit>");
+  console.log("  status                         show whether agent support reports are allowed");
+  console.log("  enable [--yes]                 allow agents to send bounded reports to Monty");
+  console.log("  disable                        stop all future reports immediately");
+  console.log("  submit --data '<json|->'       send an incident, unexpected behavior, or missing feature");
+  console.log('report JSON: {"kind":"incident|unexpected_behavior|missing_feature","title":"…","summary":"…","problem":"…","expected":"…","attempted":["…"],"error":"…"}');
+  process.exit(1);
+}
+
+function redactSupportText(value) {
+  return value
+    .replaceAll(homedir(), "~")
+    .replace(/mk_[0-9a-f]{48}/gi, "[REDACTED_CLI_KEY]")
+    .replace(/\bBearer\s+[^\s"']+/gi, "Bearer [REDACTED]")
+    .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[REDACTED_JWT]")
+    .replace(/([?&](?:ticket|token|key)=)[^&\s]+/gi, "$1[REDACTED]")
+    .replace(/\b([A-Z][A-Z0-9_]*(?:SECRET|TOKEN|PASSWORD|API_KEY))=\S+/g, "$1=[REDACTED]");
+}
+
+async function supportDiagnostics(appDir, host, includeLogs) {
+  let session;
+  let errorLog;
+  if (appDir) {
+    const probe = await checkDevSession(appDir);
+    const recorded = probe.session;
+    if (recorded) {
+      session = JSON.stringify({
+        live: probe.live,
+        ...(probe.reason ? { reason: probe.reason } : {}),
+        state: recorded.state ?? null,
+        cli: recorded.cli ?? null,
+        pid: Number.isInteger(recorded.pid) ? recorded.pid : null,
+        port: Number.isInteger(recorded.port) ? recorded.port : null,
+        sessionId: typeof recorded.sessionId === "string" ? recorded.sessionId : null,
+        startedAt: recorded.startedAt ?? null,
+        updatedAt: recorded.updatedAt ?? null,
+        loggedIn: recorded.loggedIn ?? null,
+        lastHeartbeatAt: recorded.lastHeartbeatAt ?? null,
+      });
+    }
+    if (includeLogs) {
+      const diagnosticLines = readLogTail(appDir, 240)
+        .filter((line) => /\b(error|warn|failed|failure|takeover|superseded|drift)\b|\[MontyError\]/i.test(line))
+        .slice(-80);
+      if (diagnosticLines.length) {
+        errorLog = redactSupportText(diagnosticLines.join("\n")).slice(-12_000);
+      }
+    }
+  }
+  return {
+    cliVersion: CLI_VERSION,
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    host,
+    ...(session ? { session: redactSupportText(session) } : {}),
+    ...(errorLog ? { errorLog } : {}),
+  };
+}
+
+async function supportRequest(method, payload) {
+  const { host, key } = loadConfig();
+  if (!key) {
+    fail("NOT_LOGGED_IN", `Support settings and reports need your workspace (${host}). Run \`monty login\` first.`);
+  }
+  let response;
+  try {
+    response = await fetch(`${host}/api/support`, {
+      method,
+      headers: {
+        authorization: `Bearer ${key}`,
+        ...(payload === undefined ? {} : { "content-type": "application/json" }),
+      },
+      ...(payload === undefined ? {} : { body: JSON.stringify(payload) }),
+      signal: AbortSignal.timeout(15_000),
+    });
+  } catch {
+    fail("SUPPORT_UNREACHABLE", `Could not reach ${host}/api/support. Check the network and retry.`);
+  }
+  const body = await response.json().catch(() => null);
+  if (!response.ok || !body?.ok) {
+    fail(body?.code ?? `HTTP_${response.status}`, body?.fix ?? "The support request failed. Retry once.");
+  }
+  return { host, body };
+}
+
+async function support() {
+  const verb = rest[0];
+  if (!verb || rest.includes("--help") || rest.includes("-h")) supportUsage();
+
+  if (verb === "status") {
+    const { body } = await supportRequest("GET");
+    console.log(`support sharing: ${body.enabled ? "enabled" : "disabled"}`);
+    if (body.enabledAt) console.log(`enabled at: ${new Date(body.enabledAt).toISOString()}`);
+    return;
+  }
+
+  if (verb === "enable") {
+    console.log("Monty support sharing lets coding agents report persistent Monty platform errors and missing platform features.");
+    console.log("Reports include: an agent-written summary, tool identity, CLI and session metadata, and selected recent error or warning lines with known secrets redacted.");
+    console.log("Error lines may contain names or values that a tool printed. Agents can omit them per report with includeLogs: false.");
+    console.log("The command does not read source files, environment variables, tool records, or the full conversation.");
+    let approved = rest.includes("--yes");
+    if (!approved && process.stdin.isTTY && process.stdout.isTTY) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      approved = /^y(?:es)?$/i.test((await rl.question("Allow these reports for this workspace? [y/N] ")).trim());
+      rl.close();
+    }
+    if (!approved) {
+      fail("SUPPORT_CONSENT_REQUIRED", "A person must approve support sharing. Review the notice above, ask the workspace admin, then rerun `monty support enable --yes` only after they agree.");
+    }
+    await supportRequest("PUT", { enabled: true });
+    console.log("support sharing: enabled");
+    return;
+  }
+
+  if (verb === "disable") {
+    await supportRequest("PUT", { enabled: false });
+    console.log("support sharing: disabled");
+    return;
+  }
+
+  if (verb !== "submit") supportUsage();
+
+  const rawData = flag("data");
+  if (rawData === undefined) {
+    fail("SUPPORT_REPORT_REQUIRED", "Pass the agent summary with `monty support submit --data '<json>'`. Use `--data -` to read JSON from stdin.");
+  }
+  let input;
+  try {
+    const raw = rawData === "-" ? readFileSync(0, "utf8") : rawData;
+    input = JSON.parse(raw);
+  } catch {
+    fail("BAD_SUPPORT_REPORT", "The support report is not valid JSON. Pass one object with kind, title, summary, problem, expected, and optional attempted/error fields.");
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    fail("BAD_SUPPORT_REPORT", "The support report must be one JSON object.");
+  }
+  const kinds = new Set(["incident", "unexpected_behavior", "missing_feature"]);
+  if (!kinds.has(input.kind)) {
+    fail("BAD_SUPPORT_REPORT", "kind must be `incident`, `unexpected_behavior`, or `missing_feature`.");
+  }
+  for (const field of ["title", "summary", "problem", "expected"]) {
+    if (typeof input[field] !== "string" || !input[field].trim()) {
+      fail("BAD_SUPPORT_REPORT", `${field} must be a non-empty string.`);
+    }
+  }
+  if (input.attempted !== undefined && (!Array.isArray(input.attempted) || input.attempted.some((item) => typeof item !== "string"))) {
+    fail("BAD_SUPPORT_REPORT", "attempted must be an array of short strings.");
+  }
+  if (input.error !== undefined && typeof input.error !== "string") {
+    fail("BAD_SUPPORT_REPORT", "error must be a string when provided.");
+  }
+  if (input.includeLogs !== undefined && typeof input.includeLogs !== "boolean") {
+    fail("BAD_SUPPORT_REPORT", "includeLogs must be true or false when provided.");
+  }
+
+  const appDir = findAppRoot(process.cwd());
+  const { host } = loadConfig();
+  const appSlug = typeof input.appSlug === "string"
+    ? input.appSlug
+    : appDir
+      ? readSlugFromConfig(appDir)
+      : undefined;
+  const report = {
+    ...(appSlug ? { appSlug } : {}),
+    kind: input.kind,
+    title: redactSupportText(input.title.trim()),
+    threadSummary: redactSupportText(input.summary.trim()),
+    problem: redactSupportText(input.problem.trim()),
+    expected: redactSupportText(input.expected.trim()),
+    attempted: (input.attempted ?? [])
+      .map((item) => redactSupportText(item.trim()))
+      .filter(Boolean),
+    ...(input.error?.trim() ? { error: redactSupportText(input.error.trim()) } : {}),
+    diagnostics: await supportDiagnostics(
+      appDir,
+      host,
+      input.includeLogs ?? input.kind !== "missing_feature",
+    ),
+  };
+  const { body } = await supportRequest("POST", report);
+  console.log(`support ticket: ${body.ticketId}`);
+  console.log("support: submitted to Monty");
+}
+
 // ── dispatch ───────────────────────────────────────────────────────────────
 // Keep agent skills fresh on every invocation (user level + current app).
 // `dev` and `logs` skip the refresh here: attach and log reads must stay
 // fast (a skills refresh can shell out to npx for two minutes) — dev's
 // fresh-start path installs skills itself once it owns the session.
-if (command !== "dev" && command !== "logs") {
+if (command !== "dev" && command !== "logs" && command !== "support") {
   installSkills({ appDir: findAppRoot(process.cwd()) });
 }
 
@@ -3419,11 +3791,17 @@ switch (command) {
   case "schema":
     await schemaCmd();
     break;
+  case "views":
+    await views();
+    break;
+  case "support":
+    await support();
+    break;
   case "secret":
     await secret();
     break;
   default:
-    console.log("usage: monty <login|create|pull|log|current|select|apps|install|dev|logs|build|typecheck|add|components|docs|save|data|skills>");
+    console.log("usage: monty <login|create|pull|log|current|select|apps|install|dev|logs|build|typecheck|add|components|docs|save|data|schema|views|support|skills>");
     console.log("  login       [--host <url>] [--key <mk_...>]  sign in (opens your browser to authorize)");
     console.log("  create      <slug> [--name N] [--icon I] [--spa]  register a new app (config-only by default; --spa scaffolds the full SPA)");
     console.log("  pull        <slug> [--version H] [--force]  restore the app's source snapshot (latest, or one from `monty log`)");
@@ -3443,6 +3821,8 @@ switch (command) {
     console.log("  deploy                                      alias of save");
     console.log("  data        <verb> [table] [flags]          read/write an app's records from the terminal (`monty data` for verbs)");
     console.log("  schema      [slug] | set <file|->            read the app's stored manifest (JSON on stdout) / write it back (validated, CAS)");
+    console.log("  views       <list|set|update|remove> <table> manage shared saved views on a system record page");
+    console.log("  support     <status|enable|disable|submit>   opt in and send agent-authored platform reports to Monty");
     console.log("  skills                                      install/refresh the agent build skill");
     process.exit(command ? 1 : 0);
 }

package/lib/views.mjs

@@ -0,0 +1,138 @@
+function badViewConfig(fix, code = "BAD_VIEW_CONFIG") {
+  const error = new Error(fix);
+  error.code = code;
+  error.fix = fix;
+  throw error;
+}
+
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function valueToken(value, field) {
+  if (value === null || value === "") return "(empty)";
+  if (["string", "number", "boolean"].includes(typeof value)) return String(value);
+  badViewConfig(
+    `Filter "${field}" must be null, a string, number, boolean, an array of those values, { contains }, { min/max }, or a full saved-view filter.`,
+  );
+}
+
+function valuesFilter(values, field) {
+  if (values.length === 0) {
+    badViewConfig(`Filter "${field}" has no values. Remove it or provide at least one value.`);
+  }
+  return { kind: "values", values: [...new Set(values.map((value) => valueToken(value, field)))] };
+}
+
+function rangeFilter(input, field) {
+  const min = input.min;
+  const max = input.max;
+  if (min === undefined && max === undefined) {
+    badViewConfig(`Range filter "${field}" needs min, max, or both.`);
+  }
+  if (min !== undefined && (typeof min !== "number" || !Number.isFinite(min))) {
+    badViewConfig(`Range filter "${field}" has a non-numeric min.`);
+  }
+  if (max !== undefined && (typeof max !== "number" || !Number.isFinite(max))) {
+    badViewConfig(`Range filter "${field}" has a non-numeric max.`);
+  }
+  if (min !== undefined && max !== undefined && min > max) {
+    badViewConfig(`Range filter "${field}" has min greater than max.`);
+  }
+  return {
+    kind: "range",
+    ...(min !== undefined ? { min } : {}),
+    ...(max !== undefined ? { max } : {}),
+  };
+}
+
+function normalizeFilter(input, field) {
+  if (Array.isArray(input)) return valuesFilter(input, field);
+  if (!isObject(input)) return valuesFilter([input], field);
+
+  if (input.kind === "values") {
+    if (!Array.isArray(input.values)) {
+      badViewConfig(`Values filter "${field}" needs a values array.`);
+    }
+    return valuesFilter(input.values, field);
+  }
+  if (input.kind === "text" || (input.kind === undefined && "contains" in input)) {
+    if (typeof input.contains !== "string" || input.contains === "") {
+      badViewConfig(`Text filter "${field}" needs a non-empty contains string.`);
+    }
+    return { kind: "text", contains: input.contains };
+  }
+  if (input.kind === "range" || (input.kind === undefined && ("min" in input || "max" in input))) {
+    return rangeFilter(input, field);
+  }
+  badViewConfig(
+    `Filter "${field}" is not recognized. Use a value, an array, { contains }, { min/max }, or a full saved-view filter.`,
+  );
+}
+
+/**
+ * Agent-facing filters stay concise while the stored value is exactly the
+ * shell's existing ViewConfig shape.
+ *
+ *   { pipelineId: null }                 -> empty values filter
+ *   { status: ["Evaluate", "New"] }     -> values filter
+ *   { title: { contains: "Director" } }  -> text filter
+ *   { amount: { min: 100 } }             -> range filter
+ */
+export function normalizeViewFilters(input) {
+  if (input === undefined) return {};
+  if (!isObject(input)) {
+    badViewConfig("--filter must be one JSON object keyed by field name.");
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([field, filter]) => {
+      if (field.trim() === "") badViewConfig("View filter field names cannot be empty.");
+      return [field, normalizeFilter(filter, field)];
+    }),
+  );
+}
+
+export function parseViewSort(input) {
+  if (input === undefined) return null;
+  if (input === "none") return null;
+  const match = /^([^:]+):(asc|desc)$/.exec(input);
+  if (!match) {
+    badViewConfig('--sort must be shaped like "field:asc" or "field:desc", or be "none" to clear it.');
+  }
+  return { column: match[1], dir: match[2] };
+}
+
+export function parseHiddenColumns(input) {
+  if (input === undefined || input.trim() === "") return [];
+  return [...new Set(input.split(",").map((field) => field.trim()).filter(Boolean))];
+}
+
+export function mergeViewConfig(existing, patch) {
+  const base = isObject(existing) ? existing : {};
+  return {
+    filters: Object.hasOwn(patch, "filters")
+      ? patch.filters
+      : (isObject(base.filters) ? base.filters : {}),
+    sort: Object.hasOwn(patch, "sort") ? patch.sort : (base.sort ?? null),
+    hidden: Object.hasOwn(patch, "hidden")
+      ? patch.hidden
+      : (Array.isArray(base.hidden) ? base.hidden : []),
+  };
+}
+
+export function validateViewColumns(config, fieldNames) {
+  const known = new Set(fieldNames);
+  const used = [
+    ...Object.keys(config.filters),
+    ...(config.sort ? [config.sort.column] : []),
+    ...config.hidden,
+  ];
+  const unknown = [...new Set(used.filter((field) => !known.has(field)))];
+  if (unknown.length > 0) {
+    badViewConfig(
+      `Unknown view field${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")}. Available fields: ${fieldNames.join(", ") || "(none)"}.`,
+      "UNKNOWN_VIEW_FIELD",
+    );
+  }
+  return config;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@montytools/cli",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/TomasMonty/monty-v2.git",
@@ -21,7 +21,8 @@
   },
   "scripts": {
     "prepack": "node scripts/bundle-template.mjs",
-    "typecheck": "node --check bin/monty.mjs && node --check lib/compile.mjs && node --check lib/schemaCodegen.mjs && node --check lib/schemaPull.mjs && node --check scripts/schema-roundtrip.mjs",
+    "typecheck": "node --check bin/monty.mjs && node --check lib/compile.mjs && node --check lib/schemaCodegen.mjs && node --check lib/schemaPull.mjs && node --check lib/views.mjs && node --check scripts/schema-roundtrip.mjs",
+    "test": "node --test test/views.test.mjs",
     "postinstall": "node bin/postinstall.mjs",
     "test:roundtrip": "node scripts/schema-roundtrip.mjs"
   },

package/skills/monty-build/SKILL.md

@@ -60,7 +60,10 @@ channel switch. "dev"/"prod" mean platform environments, never app states.
 4. **One import surface:** `@montytools/sdk` (`defineApp`, zod) and
    `@montytools/sdk/react` (hooks: `useList`, `useInsert`, …). Never import
    Clerk or Convex directly; never fetch external APIs from app code — the
-   platform CSP blocks them.
+   platform CSP blocks them. Open external HTTPS pages with
+   `openExternal(url)` from `@montytools/sdk`, called synchronously from the
+   click or key handler; `window.open` and `target="_blank"` are blocked by
+   the app iframe.
 5. **The data schema lives in the WORKSPACE, not in code.** Read it with
    `monty schema` (JSON on stdout); change it by editing that JSON and
    running `monty schema set <file>` — validated server-side, additive by
@@ -71,17 +74,38 @@ channel switch. "dev"/"prod" mean platform environments, never app states.
    manifest BEFORE shipping its route — a save with an undeclared route
    refuses with the fix. Field names `_*`, `updatedAt`, `createdBy` are
    reserved.
-6. **UI is stock shadcn** (preset already wired). Add curated components with
+6. **Prefer a saved view for filtered tables.** If the request is
+   one table with different filters, sorting, or hidden columns, use
+   `monty views set <table> <name> ...`. For example, an evaluation queue is
+   `monty views set leads "Evaluate" --filter '{"pipelineId":null}'`.
+   Change selected properties or rename it later with
+   `monty views update <table> <name> ...`; omitted properties stay unchanged.
+   If that table needs actions, compose `RecordPage` from
+   `@montytools/sdk/react` and add typed row/header/selection/record actions
+   with the controls from `@montytools/sdk/ui`. Write the whole page yourself
+   only when the shared components no longer fit. Custom pages remain the
+   escape hatch.
+7. **UI is stock shadcn** (preset already wired). Add curated components with
    `monty add <name>`; browse with `monty components` / `monty docs <name>`.
    How pages should LOOK — Lyra surfaces, dark-only, the chart language — is
    the `monty-design` skill; read it before styling any page.
-7. **Errors are instructions.** Every failure prints
+8. **Errors are instructions.** Every failure prints
    `[MontyError CODE] Fix: …` — do exactly what the Fix says; don't guess.
    Typecheck failures block the save by design.
-8. **Edits are real.** The dev shell reads and writes the app's LIVE
+9. **Edits are real.** The dev shell reads and writes the app's LIVE
    records — there is one set of data, and every write journals into the
    app's Activity. Exercise the app for real; clean up test rows you
    create; never seed junk into a team's working tables.
+10. **Report platform failures when sharing is enabled.** `monty support
+   status` shows whether a workspace admin has allowed agent support
+   reports. If enabled, submit one report when a Monty platform error still
+   blocks the task after you followed its `Fix` and retried, or when the
+   requested work needs a missing Monty platform feature. Summarize the
+   thread. State the observed problem, expected behavior, attempted fixes,
+   and exact error. Do not paste the full conversation. If sharing is off,
+   ask the user before running `monty support enable --yes`; never grant
+   consent yourself. Do not file reports for ordinary app-code bugs or send
+   duplicates for the same incident.
 
 ## CLI reference
 
@@ -96,5 +120,7 @@ channel switch. "dev"/"prod" mean platform environments, never app states.
 | `monty add <name…>` | install curated shadcn components |
 | `monty schema [slug]` | print the app's stored manifest (tables, pages, metrics) as JSON |
 | `monty schema set <file\|->` | write an edited manifest back (validated, CAS, additive by default) |
+| `monty views <list\|set\|update\|remove> <table>` | manage the shared saved views on a system record page |
 | `monty save ["what changed"]` | push the working copy to the cloud copy, like `git push main` (build + typecheck gate it) |
+| `monty support <status\|enable\|disable\|submit>` | manage consent and send a bounded agent-authored platform report |
 | `monty skills` | (re)install this skill for your agent |

package/template/AGENTS.md

@@ -106,6 +106,19 @@ await update(row._id, { receipt });                     // store descriptor, not
 const { url } = useFileUrl(app, row.receipt);            // authenticated blob: URL for previews/downloads
 ```
 
+Open an external HTTPS page with the SDK. Do not use `target="_blank"` or
+`window.open`; the app iframe blocks popups by design. Call `openExternal`
+synchronously from the click or key handler so the host can verify current
+user activation:
+
+```tsx
+import { openExternal } from "@montytools/sdk";
+
+<Button onClick={() => openExternal(profile.linkedinUrl)}>
+  Open LinkedIn
+</Button>
+```
+
 ## Derived fields, metrics, pages (V2 — the platform renders these)
 
 Your config can carry a whole database app the platform shell renders for
@@ -153,6 +166,12 @@ export const app = defineApp({
 
 Rules that matter:
 
+- **A filtered or sorted slice of one table is a saved view.** Use
+  `monty views set <table> <name> ...` before writing a route. For example,
+  `monty views set leads "Evaluate" --filter '{"pipelineId":null}'` creates
+  a shared record view without React. Use `monty views update` to change only
+  selected properties or rename it. Custom pages remain available when the
+  requested interaction, multi-table layout, or visualization needs code.
 - **Custom pages wear the platform chrome from `@montytools/sdk/ui`** — the
   SAME components the shell renders its own pages with, so your page is
   indistinguishable from a system table view. Every custom page opens with
@@ -179,6 +198,13 @@ Rules that matter:
   mode strips) and the Lyra table classes `SURFACE`/`THEAD`/`TH`/`ROW`/`CHIP`
   for record-like tables (`<div className={SURFACE}><table>…`), identical to
   the app's Configuration surfaces.
+- **Extend records before rebuilding them.** For a custom page that is still
+  one table, use `RecordPage` from `@montytools/sdk/react`. Add behavior with
+  its typed `headerActions`, `rowActions`, `selectionActions`, and
+  `recordActions` callbacks. Use `RecordActionButton` and the lower-level
+  `RecordPage*`/`RecordTable*` components from `@montytools/sdk/ui` when you
+  need a different composition. Drop to a fully custom page only when those
+  components no longer fit.
 - **Formulas are strings**, not functions — the Monty expression grammar
   (`+ - * / %`, comparisons, `&& || !`, `IF/ROUND/ABS/MIN/MAX`,
   `metrics.<name>`). A formula sees only fields declared ABOVE it. Type

package/template/package.json

@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@fontsource-variable/roboto": "^5.2.10",
-    "@montytools/sdk": "^0.2.2",
+    "@montytools/sdk": "^0.2.4",
     "@tanstack/react-router": "1.170.17",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",