@montytools/cli 0.5.4 → 0.5.5

package/bin/monty.mjs

@@ -15,16 +15,15 @@ import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { CATALOG, REGISTRIES } from "./catalog.mjs";
-import { CompileError, compileAppConfig } from "../lib/compile.mjs";
+import { 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";
+import { mergeViewConfig, normalizeViewFilters, parseHiddenColumns, parseKanbanFlag, 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
 // Monty state coexists on one machine — the desktop's dev channel points it
-// at ~/.monty-dev so platform development never touches the real state. A
-// custom root is a sandbox: the legacy visible home (~/Monty) is not scanned.
+// at ~/.monty-dev so platform development never touches the real state.
 const CONFIG_DIR = process.env.MONTY_HOME
   ? resolve(process.env.MONTY_HOME)
   : join(homedir(), ".monty");
@@ -50,11 +49,9 @@ const ANSI_RE = new RegExp(
 // Every app's source lives in one predictable, hidden place: `monty create`
 // registers the app first and the server-minted id names the folder
 // (~/.monty/apps/<id>) — id-keyed because slugs may be renamed later; the
-// `id` stamped into monty.config.ts is the durable identity. `monty login`
-// provisions the home; --dir overrides per create. Pre-id apps in the legacy
-// visible home (~/Monty) keep working — every scan reads both.
+// `id` stamped into .monty/app.json is the durable identity. `monty login`
+// provisions the home; --dir overrides per create.
 const MONTY_HOME = join(CONFIG_DIR, "apps");
-const LEGACY_MONTY_HOME = join(homedir(), "Monty");
 
 const [, , command, ...rest] = process.argv;
 
@@ -116,22 +113,16 @@ function findMontyrcHost(startDir) {
   return null;
 }
 
-// Reads config.json in either shape: legacy { host, key } (migrated on the
-// next login) or { defaultHost, profiles: { [host]: { key } } }.
+// Reads config.json: { defaultHost, profiles: { [host]: { key } } }.
 function normalizedConfig() {
   let raw = null;
   try {
     raw = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
   } catch { /* not logged in anywhere yet */ }
-  if (!raw) return { defaultHost: null, profiles: {} };
-  if (raw.profiles && typeof raw.profiles === "object") {
-    return { defaultHost: raw.defaultHost ?? null, profiles: raw.profiles };
+  if (!raw?.profiles || typeof raw.profiles !== "object") {
+    return { defaultHost: null, profiles: {} };
   }
-  const legacyHost = (raw.host ?? DEFAULT_HOST).replace(/\/+$/, "");
-  return {
-    defaultHost: legacyHost,
-    profiles: raw.key ? { [legacyHost]: { key: raw.key } } : {},
-  };
+  return { defaultHost: raw.defaultHost ?? null, profiles: raw.profiles };
 }
 
 function resolveHost() {
@@ -344,11 +335,9 @@ function installSkills({ appDir = null, silent = true, force = false } = {}) {
   }
 }
 
-// ── monty current / select / apps ───────────────────────────────────────────
-// Folder management users never think about: every app lives in ~/Monty,
-// `current` says where you are, `select` prints the folder for cd $(...).
+// ── monty current ──────────────────────────────────────────────────────────
 // The app-root marker is the IDENTITY STAMP (.monty/app.json — written by
-// create and pull) or, for older folders, monty.config.ts.
+// create and connect) or, transitionally, monty.config.ts.
 function isAppRoot(dir) {
   return existsSync(join(dir, ".monty", "app.json")) || existsSync(join(dir, "monty.config.ts"));
 }
@@ -400,58 +389,15 @@ function readIdFromConfig(dir) {
   }
 }
 
-function scanAppsHome(root) {
-  if (!existsSync(root)) return [];
-  return readdirSync(root)
-    .map((name) => join(root, name))
-    .filter((p) => isAppRoot(p))
-    .map((p) => ({ path: p, slug: readSlugFromConfig(p) ?? basename(p), id: readIdFromConfig(p) }));
-}
-
-function listLocalApps() {
-  // A MONTY_HOME sandbox lists only its own apps — leaking the legacy home
-  // into an isolated root would defeat the isolation.
-  return process.env.MONTY_HOME
-    ? scanAppsHome(MONTY_HOME)
-    : [...scanAppsHome(MONTY_HOME), ...scanAppsHome(LEGACY_MONTY_HOME)];
-}
-
 function current() {
   const root = findAppRoot(process.cwd());
   if (!root) {
-    fail("NOT_IN_APP", `You are not inside a Monty app. \`monty apps\` lists local apps; cd "$(monty select <slug>)" jumps to one.`);
+    fail("NOT_IN_APP", "You are not inside a Monty app. cd into the app's folder (`monty connect <slug>` pulls a copy into any folder).");
   }
   console.log(`app: ${readSlugFromConfig(root) ?? "?"}`);
   const id = readIdFromConfig(root);
   if (id) console.log(`id: ${id}`);
   console.log(`path: ${root}`);
-  if (!root.startsWith(MONTY_HOME) && !root.startsWith(LEGACY_MONTY_HOME)) {
-    console.log(`note: outside ${MONTY_HOME} (fine, but apps normally live there)`);
-  }
-}
-
-function select() {
-  const slug = rest.find((a) => !a.startsWith("--"));
-  if (!slug) {
-    fail("MISSING_SLUG", `Usage: cd "$(monty select <slug>)" — prints the app's folder.`);
-  }
-  const apps = listLocalApps();
-  const hit = apps.find((a) => a.slug === slug || a.id === slug || basename(a.path) === slug);
-  if (!hit) {
-    const known = apps.map((a) => a.slug).join(", ") || "(none)";
-    fail("APP_NOT_LOCAL", `No local source for "${slug}" on this machine. Local apps: ${known}. Create it with \`monty create ${slug}\`.`);
-  }
-  // Bare path on stdout so command substitution works: cd "$(monty select x)"
-  console.log(hit.path);
-}
-
-function apps() {
-  const local = listLocalApps();
-  if (!local.length) {
-    console.log(`no local apps in ${MONTY_HOME} — create one with \`monty create <slug>\``);
-    return;
-  }
-  for (const a of local) console.log(`${a.slug}\t${a.path}`);
 }
 
 // Pack the app's source tree (node_modules/dist/.monty/.git excluded) into a
@@ -488,7 +434,7 @@ function readSlug(appDir) {
 // (Not `monty logs` — that tails the dev shell.)
 async function versionsLog() {
   const slug = rest.find((a) => !a.startsWith("-")) ?? readSlug(process.cwd());
-  if (!slug) fail("NO_SLUG", "Usage: monty log [slug] — or run it inside an app folder.");
+  if (!slug) fail("NO_SLUG", "Usage: monty history [slug] — or run it inside an app folder.");
   const { host, key } = loadConfig();
   if (!key) fail("NOT_LOGGED_IN", "Run `monty login` first.");
   const res = await fetch(`${host}/api/source?slug=${slug}&list=1`, {
@@ -531,7 +477,7 @@ async function pull() {
   }
   const app = appsBody.apps.find((a) => a.slug === slug);
   if (!app) {
-    fail("APP_NOT_FOUND", `No app "${slug}" in this workspace. \`monty apps\` lists what exists.`);
+    fail("APP_NOT_FOUND", `No app "${slug}" in this workspace — check the app list at ${host}.`);
   }
   // --version <hash-prefix>: restore a specific snapshot from `monty log`
   // instead of the newest one. Prefixes resolve against the history list.
@@ -548,7 +494,7 @@ async function pull() {
     }
     const matches = vbody.versions.filter((v) => v.hash.startsWith(versionFlag));
     if (matches.length === 0) {
-      fail("VERSION_NOT_FOUND", `No version of "${slug}" matches "${versionFlag}". \`monty log ${slug}\` lists what exists.`);
+      fail("VERSION_NOT_FOUND", `No version of "${slug}" matches "${versionFlag}". \`monty history ${slug}\` lists what exists.`);
     }
     if (matches.length > 1) {
       fail("VERSION_AMBIGUOUS", `"${versionFlag}" matches ${matches.length} versions — use more characters of the hash.`);
@@ -558,7 +504,10 @@ async function pull() {
   } else if (!app.sourceHash) {
     fail("NO_SOURCE", `"${slug}" has no source snapshot yet — snapshots ride each \`monty save\`. Run it once from the machine that has the source, then pull works everywhere.`);
   }
-  const target = app.id ? join(MONTY_HOME, app.id) : join(LEGACY_MONTY_HOME, slug);
+  if (!app.id) {
+    fail("APP_ID_MISSING", `"${slug}" has no app id in the workspace registry — save it once from a machine that has its source, then pull works.`);
+  }
+  const target = join(MONTY_HOME, app.id);
   if (existsSync(target) && !rest.includes("--force")) {
     fail("DIR_EXISTS", `${target} already exists and may hold unsaved work. Compare it with the saved version first; re-run with --force to REPLACE it with the snapshot.`);
   }
@@ -620,6 +569,130 @@ async function pull() {
   console.log("next: `monty install`, then `monty dev`.");
 }
 
+// ── monty connect ──────────────────────────────────────────────────────────
+// The one command that turns ANY folder into a working copy of a cloud app:
+// `monty connect <slug> [dir]` (dir defaults to the current folder) pulls
+// the app's files, installs dependencies, stamps identity, and registers
+// the checkout so the desktop's picker sees it. Apps without a source
+// snapshot but with a manifest get the config-only scaffold synced from the
+// registry. Multiple copies of one app on a machine are fine.
+async function connect() {
+  const [slugArg, dirArg] = rest.filter((a) => !a.startsWith("--"));
+  if (!slugArg || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slugArg)) {
+    fail("INVALID_SLUG", "Usage: monty connect <slug> [dir] — pulls the app into dir (default: the current folder, which must be empty).");
+  }
+  const slug = slugArg;
+  const { host, key } = loadConfig();
+  if (!key) {
+    fail("NOT_LOGGED_IN", `Connecting needs your workspace (${host}). Run \`monty login\` first.`);
+  }
+  const appsRes = await fetch(`${host}/api/apps`, { headers: { authorization: `Bearer ${key}` } });
+  const appsBody = await appsRes.json().catch(() => null);
+  if (!appsRes.ok || !appsBody?.ok) {
+    fail(appsBody?.code ?? `HTTP_${appsRes.status}`, appsBody?.fix ?? "Could not list workspace apps — check the connection and `monty login`.");
+  }
+  const app = appsBody.apps.find((a) => a.slug === slug);
+  if (!app) {
+    fail("APP_NOT_FOUND", `No app "${slug}" in this workspace — check the app list at ${host}.`);
+  }
+
+  const target = resolve(process.cwd(), dirArg ?? ".");
+  if (existsSync(target)) {
+    if (!statSync(target).isDirectory()) {
+      fail("NOT_A_DIRECTORY", `${target} is a file. Point \`monty connect\` at a folder.`);
+    }
+    if (readdirSync(target).filter((n) => n !== ".DS_Store").length > 0) {
+      // A folder that already holds THIS app needs nothing — the working
+      // copy is untouched.
+      const stamp = readAppJson(target);
+      if (stamp && ((app.id && stamp.id === app.id) || stamp.slug === slug)) {
+        console.log(`connected: ${slug} -> ${target} (already a copy of this app)`);
+        console.log("next: `monty dev`");
+        return;
+      }
+      fail("DIR_NOT_EMPTY", `${target} is not empty. Connect pulls the app's files INTO the folder — run it in an empty one, or name a new folder: \`monty connect ${slug} ${slug}\`.`);
+    }
+  }
+
+  if (app.sourceHash) {
+    console.log(`connect: ${slug} <- ${host}`);
+    const res = await fetch(`${host}/api/source?slug=${slug}`, {
+      headers: { authorization: `Bearer ${key}` },
+    });
+    if (!res.ok) {
+      const b = await res.json().catch(() => null);
+      fail(b?.code ?? `HTTP_${res.status}`, b?.fix ?? "Downloading the snapshot failed — retry.");
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    const hash = createHash("sha256").update(buf).digest("hex");
+    if (hash !== app.sourceHash) {
+      fail("SOURCE_CORRUPT", "The downloaded snapshot failed verification — retry; if it persists, run `monty save` again from a machine that has the source.");
+    }
+    // Extract into a sibling staging folder first — a failed extract never
+    // leaves a half-written copy. An existing (empty) target keeps its
+    // inode: staging contents MOVE in, so a shell sitting in it stays sane.
+    const staging = `${target}.connect-tmp`;
+    rmSync(staging, { recursive: true, force: true });
+    mkdirSync(staging, { recursive: true });
+    const tarFile = join(staging, ".source.tar.gz");
+    writeFileSync(tarFile, buf);
+    const untar = spawnSync("tar", ["-xzf", tarFile, "-C", staging], { stdio: "pipe" });
+    rmSync(tarFile, { force: true });
+    if (untar.status !== 0) {
+      rmSync(staging, { recursive: true, force: true });
+      fail("EXTRACT_FAILED", "Unpacking the snapshot failed. Retry; if it persists, run `monty save` again from a machine that has the source.");
+    }
+    if (existsSync(target)) {
+      for (const name of readdirSync(staging)) renameSync(join(staging, name), join(target, name));
+      rmSync(staging, { recursive: true, force: true });
+    } else {
+      renameSync(staging, target);
+    }
+    try {
+      const cfg = await fetch(`${host}/api/config`).then((r) => r.json());
+      writeFileSync(
+        join(target, ".env.local"),
+        `VITE_CONVEX_URL=${cfg.convexUrl}\nVITE_CLERK_PUBLISHABLE_KEY=${cfg.clerkPublishableKey}\n`,
+      );
+    } catch {
+      console.log(`config: WARNING — could not reach ${host}/api/config; copy .env.example to .env.local manually`);
+    }
+    mkdirSync(join(target, ".monty"), { recursive: true });
+    writeFileSync(
+      join(target, ".monty", "source.json"),
+      JSON.stringify({ hash, syncedAt: Date.now() }) + "\n",
+    );
+  } else {
+    // No snapshot: the app's config in the workspace IS the app — a
+    // config-only scaffold synced from it is a complete working copy.
+    console.log(`connect: ${slug} <- ${host} (config-only — the workspace holds the app's config)`);
+    if (typeof app.id !== "string" || !/^[a-z0-9]{10,64}$/i.test(app.id)) {
+      fail("APP_ID_MISSING", `"${slug}" has no usable app id in the workspace registry — save it once from a machine that has it, then connect works.`);
+    }
+    mkdirSync(target, { recursive: true });
+    writeConfigOnlyScaffold(target, { appId: app.id, slug, name: app.name, icon: app.icon });
+    try {
+      await schemaPull({ appDir: target, host, key, slug, force: true, compileAppConfig, fail });
+    } catch {
+      console.log("schema: could not sync the app's config yet — `monty schema pull` retries it");
+    }
+  }
+
+  // The snapshot excludes .monty/ — the workspace row is the authority for
+  // identity, so stamp it fresh.
+  writeAppJson(target, {
+    ...(app.id ? { id: app.id } : {}),
+    slug,
+    ...(app.name ? { name: app.name } : {}),
+    ...(app.icon ? { icon: app.icon } : {}),
+  });
+  if (existsSync(join(target, "package.json"))) {
+    installDepsIn(target);
+  }
+  console.log(`connected: ${slug} -> ${target}`);
+  console.log(target === process.cwd() ? "next: `monty dev`" : `next: cd ${dirArg ?? target} && monty dev`);
+}
+
 // ── monty create ───────────────────────────────────────────────────────────
 // A CONFIG-ONLY app: no SPA at all — monty.config.ts is the whole app and
 // the platform shell renders it. The presence of index.html is the marker
@@ -628,6 +701,20 @@ function isConfigOnlyApp(appDir) {
   return !existsSync(join(appDir, "index.html"));
 }
 
+// Literal read of the config's `publicFns: ["a", "b"]` list — the same
+// light-touch parse the SDK's vite plugin uses.
+function readPublicFnsLiteral(appDir) {
+  try {
+    const src = readFileSync(join(appDir, "monty.config.ts"), "utf8");
+    const block = /publicFns:\s*\[([^\]]*)\]/m.exec(src)?.[1];
+    if (!block) return undefined;
+    const names = [...block.matchAll(/["']([a-zA-Z][a-zA-Z0-9_]*)["']/g)].map((m) => m[1]);
+    return names.length > 0 ? names : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 // Literal read of the config's `schedule` block ({ fn: "cron expr" }) —
 // the same light-touch parse the SDK's vite plugin uses for publicFns.
 // Registry-owned sessions read it this way so the cron ticker works
@@ -665,12 +752,12 @@ function discoverPages(appDir) {
 
 const CONFIG_ONLY_AGENTS_MD = `# This is a CONFIG-ONLY Monty app
 
-The app is rendered by the Monty platform from its WORKSPACE manifest —
+The app is rendered by the Monty platform from its config stored in the workspace —
 tables (zod), derived fields (\`rollup\`/\`lookup\`/\`formula\`), \`metrics\`,
 \`settings\`, and \`pages\`. There is no src/, no React, no build.
 
 - The schema lives in the workspace, and its door is the schema API:
-  read it with \`monty schema\`, change it with \`monty schema set <file|->\`
+  read it with \`monty schema\`, change it with \`monty schema set '<json>'\` (or pipe: \`monty schema set -\`)
   (validated, CAS-guarded, live within seconds). monty.config.ts edits do
   NOT change a workspace-owned app's schema.
 - Formulas are strings in the Monty expression grammar, e.g.
@@ -682,7 +769,7 @@ tables (zod), derived fields (\`rollup\`/\`lookup\`/\`formula\`), \`metrics\`,
   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
+- Need a bespoke page later? \`monty page add\` declares it and upgrades this
   app with a SPA scaffold; \`monty save\` ships the code.
 `;
 
@@ -725,13 +812,6 @@ async function create() {
   if (!slug || slug.length > 64 || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(slug)) {
     fail("INVALID_SLUG", 'Usage: monty create <slug> — lowercase letters/digits with single hyphens, max 64 chars (e.g. "standup-notes").');
   }
-  // An app with this slug already on disk means create is the wrong verb —
-  // fail BEFORE registering, and never suggest deleting anything: the folder
-  // may hold real, uncommitted work.
-  const dupe = listLocalApps().find((a) => a.slug === slug);
-  if (dupe) {
-    fail("APP_EXISTS", `"${slug}" already exists on this machine at ${dupe.path}. Keep working on it there (cd "$(monty select ${slug})"); pick a different slug for a new app.`);
-  }
   const name =
     flag("name") ??
     slug.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
@@ -777,7 +857,7 @@ async function create() {
   mkdirSync(dirname(target), { recursive: true });
 
   // DEFAULT: config-only — no SPA. monty.config.ts is the whole app and the
-  // platform shell renders it; \`monty add page\` scaffolds a SPA the moment a
+  // platform shell renders it; \`monty page add\` scaffolds a SPA the moment a
   // bespoke page is needed. \`--spa\` keeps the old full-SPA scaffold
   // (\`--config-only\` stays accepted as the now-default no-op).
   if (!rest.includes("--spa")) {
@@ -910,7 +990,7 @@ async function create() {
   }
 
   // Build tracking: the /new screen minted an id; recording it here lets
-  // `monty deploy` resolve it and flips the UI into "agent is working" mode.
+  // `monty save` resolve it and flips the UI into "agent is working" mode.
   const buildId = flag("build");
   if (buildId && /^[a-z0-9]{10,64}$/i.test(buildId)) {
     mkdirSync(join(target, ".monty"), { recursive: true });
@@ -937,14 +1017,17 @@ async function create() {
 // The full app lifecycle goes through the CLI — agents never invoke pnpm,
 // vite, or tsc directly. Same underlying tools, agent-shaped output, and the
 // build-before-typecheck ordering handled for you.
-function installDeps() {
-  const appDir = requireAppDir("install");
+function installDepsIn(appDir) {
   const pm = spawnSync("pnpm", ["--version"], { stdio: "ignore" }).status === 0 ? "pnpm" : "npm";
   run(appDir, "install", [pm, "install"],
     "Dependency install failed. Read the package manager error above; usually network or a bad package.json edit.");
   ensureSdk(appDir);
 }
 
+function installDeps() {
+  installDepsIn(requireAppDir("install"));
+}
+
 function buildApp() {
   const appDir = requireAppDir("build");
   run(appDir, "build", ["npx", "vite", "build"],
@@ -991,7 +1074,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.4";
+const MIN_SDK = "0.2.5";
 const SDK_VITE_CACHE_STAMP = "sdk-vite-cache-version";
 
 function installedSdkVersion(appDir) {
@@ -1451,17 +1534,16 @@ async function dev() {
 
   installSkills({ appDir });
   ensureSdk(appDir);
-  // Registry-owned apps (stamped on the first configIgnored beat): the
-  // platform reads NOTHING from the config compile — identity comes from
-  // the stamp and the compile is skipped entirely. The config file is just
-  // code the bundle imports; `schedule` (a code-door declaration the
+  // Identity comes from the .monty/app.json stamp (written by create and
+  // connect) — the platform reads NOTHING from the config file, which is
+  // just code the bundle imports. `schedule` (a code-door declaration the
   // session cron ticker needs) is read literally, the same way the vite
   // plugin reads `publicFns`.
   const stamp = readAppJson(appDir);
-  const registryOwned = stamp?.registryOwned === true && typeof stamp?.slug === "string";
-  const meta = registryOwned
-    ? { slug: stamp.slug, name: stamp.name, icon: stamp.icon, schedule: readScheduleLiteral(appDir) }
-    : await compileConfig(appDir);
+  if (typeof stamp?.slug !== "string" || !stamp.slug) {
+    fail("NOT_CONNECTED", "This folder carries no app identity (.monty/app.json). Run `monty connect <slug>` here to join an existing app, or `monty create <slug>` for a new one.");
+  }
+  const meta = { slug: stamp.slug, name: stamp.name, icon: stamp.icon, schedule: readScheduleLiteral(appDir) };
   const cfg = loadConfig();
   const host = cfg?.host ?? DEFAULT_HOST;
   // CONFIG-ONLY apps run no vite and no tunnel: `monty dev` is watch +
@@ -1493,25 +1575,16 @@ async function dev() {
   let cronTimer = null;
   let ended = false;
   let registeredOnce = false;
-  // Held-config warnings print once per drift episode, not every beat.
-  let driftAnnounced = false;
-  // The registry-owned notice prints once per session.
+  // The schema-lives-in-the-workspace notice prints once per session.
   let configIgnoredAnnounced = false;
   const devStartedAt = Date.now();
   const sessionId = `dev_${randomBytes(16).toString("hex")}`;
   const buildFile = join(appDir, ".monty", "build");
   const buildId = existsSync(buildFile) ? readFileSync(buildFile, "utf8").trim() : undefined;
-  // The session schema channel (manifest-less apps): heartbeats carry the
-  // compiled schema, and edits to monty.config.ts are re-compiled (softly)
-  // so schema changes reach the platform within one heartbeat.
-  // Registry-owned apps skip all of it — their schema lives behind the
-  // doors, and the local config copy follows the registry (auto-pull below).
-  let currentMeta = meta;
   // Once per registry change: the manifest hash we last tried to sync the
   // local config copy to (successful or refused — never loop on dirty).
   let syncAttemptedHash = null;
   const configPath = join(appDir, "monty.config.ts");
-  let configMtime = existsSync(configPath) ? statSync(configPath).mtimeMs : 0;
 
   // Advertise this session. The touch timer (not the platform heartbeat,
   // which starts minutes late or never when logged out) keeps updatedAt
@@ -1522,7 +1595,7 @@ async function dev() {
     version: 1,
     cli: CLI_VERSION,
     pid: process.pid,
-    vitePid: child.pid ?? null,
+    vitePid: child?.pid ?? null,
     tunnelPid: null,
     port,
     slug: meta.slug,
@@ -1548,12 +1621,11 @@ async function dev() {
   // Trigger on the app's fn-worker; here the CLI matches monty.config.ts
   // `schedule` entries against the UTC clock once per minute and invokes the
   // fn through the same /__monty/fn runtime (x-monty-schedule marks the
-  // lane, so ctx.viewer matches Live exactly). Config edits hot-apply via
-  // currentMeta. Fire-and-forget: a failing cron fn prints its instruction
-  // here and never blocks the loop.
+  // lane, so ctx.viewer matches Live exactly). Fire-and-forget: a failing
+  // cron fn prints its instruction here and never blocks the loop.
   let lastCronMinute = null;
   function cronTick() {
-    const sched = currentMeta?.schedule;
+    const sched = meta?.schedule;
     if (!sched || !loggedIn) return;
     const now = new Date();
     const minute = Math.floor(now.getTime() / 60_000);
@@ -1579,22 +1651,6 @@ async function dev() {
   }
   cronTimer = setInterval(cronTick, 20_000);
 
-  async function refreshSchemaIfChanged() {
-    if (registryOwned) return; // the doors own the schema; nothing to push
-    try {
-      const m = statSync(configPath).mtimeMs;
-      if (m === configMtime) return;
-      configMtime = m;
-      const fresh = await compileConfig(appDir, { soft: true });
-      if (fresh) {
-        currentMeta = fresh;
-        console.log(
-          `schema: monty.config.ts changed — session schema updated (${Object.keys(fresh.schemaJson.tables).length} tables)`,
-        );
-      }
-    } catch { /* transient fs hiccup — next beat retries */ }
-  }
-
   async function clearDevSession(timeoutMs = 2000) {
     if (cfg?.key) {
       try {
@@ -1639,7 +1695,6 @@ async function dev() {
 
   async function heartbeat(originUrl, { claim = false } = {}) {
     if (ended) return false; // shutdown already ran — no side effects
-    await refreshSchemaIfChanged();
     try {
       // Re-read the key EVERY beat: the desktop (or a fresh `monty login`)
       // may have replaced an expired key while this session runs — the
@@ -1659,23 +1714,9 @@ async function dev() {
           // owner. BOUNDED so a never-registering session (broken network)
           // can't steal the lock from a newer active session forever.
           claim: claim || (!registeredOnce && Date.now() - devStartedAt < 90_000),
-          name: currentMeta.name,
-          icon: currentMeta.icon,
+          name: meta.name,
+          icon: meta.icon,
           buildId,
-          schemaJson: currentMeta.schemaJson,
-          // App Manifest v2 (docs/manifest-v2.md) — present only for V2
-          // configs; lands only for manifest-less apps (the doors own the
-          // rest).
-          manifest: currentMeta.manifest,
-          // The CAS base for the manifest-less landing (see `monty schema
-          // pull`).
-          baseManifestHash:
-            currentMeta.manifest !== undefined ? readSchemaState(appDir)?.hash : undefined,
-          // The expose block rides the same compile as the schema — the dev
-          // visitor preview of a manifest-less app is gated on it.
-          exposure: currentMeta.exposure,
-          // Rules ride the same channel (manifest-less apps only).
-          rules: currentMeta.rules,
         }),
         signal: AbortSignal.timeout(DEV_SESSION_REQUEST_TIMEOUT_MS),
       });
@@ -1685,11 +1726,6 @@ async function dev() {
           stopSuperseded(data.fix ?? "A newer `monty dev` session is active for this app.");
           return false;
         }
-        if (data?.code === "MANIFEST_DRIFT") {
-          // Remote schema edits (another agent, via the API) — the terminal
-          // the building agent is watching gets the fix, invariant #4.
-          console.log(`schema drift (remote changes):${data.summary ? `\n${data.summary}` : ""}`);
-        }
         console.log(`dev-session: ${data?.code ?? r.status}${data?.fix ? ` — ${data.fix}` : ""}`);
         // A dead key is a SIGNED-OUT session — advertise it so the desktop
         // (which owns the session) can surface sign-in instead of letting
@@ -1699,38 +1735,15 @@ async function dev() {
         }
         return false;
       }
-      if (data?.manifestDrift) {
-        // The session registered, but the config push was HELD: the stored
-        // schema changed since this checkout last synced (another editor).
-        if (!driftAnnounced) {
-          driftAnnounced = true;
-          console.log(`schema drift (remote changes):${data.manifestDrift.summary ? `\n${data.manifestDrift.summary}` : ""}`);
-          console.log(`config push held: ${data.manifestDrift.fix ?? "Run `monty schema pull`, merge, then save again."}`);
-        }
-      } else if (currentMeta.manifest !== undefined) {
-        driftAnnounced = false;
-        // This beat's manifest landed LIVE — the new CAS base.
-        try { writeSchemaState(appDir, manifestHash(currentMeta.manifest)); } catch { /* state is advisory */ }
-      }
       if (!registeredOnce) {
         registeredOnce = true;
         sf.write({ state: "online", loggedIn: true, lastHeartbeatAt: Date.now() });
       } else {
         sf.write({ loggedIn: true, lastHeartbeatAt: Date.now() });
       }
-      if (data?.configIgnored && !configIgnoredAnnounced) {
+      if (!configIgnoredAnnounced) {
         configIgnoredAnnounced = true;
-        console.log("schema: this app's data schema lives in the workspace — monty.config.ts edits do NOT change it. Read it: `monty schema`; change it: `monty schema set <file>`.");
-        // Stamp registry ownership: from the next session on, the config
-        // compile is skipped entirely.
-        try {
-          writeAppJson(appDir, {
-            registryOwned: true,
-            slug: meta.slug,
-            ...(currentMeta.name ? { name: currentMeta.name } : {}),
-            ...(currentMeta.icon ? { icon: currentMeta.icon } : {}),
-          });
-        } catch { /* the stamp is a convenience; the beat decided */ }
+        console.log("schema: this app's data schema lives in the workspace — monty.config.ts edits do NOT change it. Read it: `monty schema`; change it: `monty schema set '<json>'` (or pipe: `monty schema set -`).");
       }
       // The local config copy follows the registry: when the stored manifest
       // moved (another editor, the schema door) and the local file is clean,
@@ -1850,26 +1863,8 @@ async function dev() {
 
   if (configOnly) {
     sf.write({ state: "ready" });
-    console.log(
-      registryOwned
-        ? "ready: config-only — the workspace owns this app's schema; edit it with `monty schema` / `monty schema set`"
-        : "ready: config-only — saves land LIVE; the workspace renders them within seconds",
-    );
+    console.log("ready: config-only — the workspace owns this app's schema; edit it with `monty schema` / `monty schema set`");
     void startDevSession();
-    if (!registryOwned) {
-      // Manifest-less apps only: config edits should land in seconds, not a
-      // heartbeat — watch the mtime and trigger an early beat (which
-      // recompiles + pushes). Registry-owned apps have nothing to push.
-      const cfgWatch = setInterval(() => {
-        try {
-          if (statSync(configPath).mtimeMs !== configMtime) void heartbeat(undefined);
-        } catch { /* transient fs hiccup */ }
-      }, 2000);
-      const stopWatch = () => clearInterval(cfgWatch);
-      process.on("SIGINT", stopWatch);
-      process.on("SIGTERM", stopWatch);
-      process.on("SIGHUP", stopWatch);
-    }
   }
 
   let announced = false;
@@ -2124,7 +2119,7 @@ function startTunnel(port, onUrlChange, onOutput) {
   });
 }
 
-// ── monty add / components / docs ──────────────────────────────────────────
+// ── monty components / page ────────────────────────────────────────────────
 // Wraps the shadcn CLI behind the curated catalog: agents ask for a
 // capability by plain name ("kanban") and get the blessed, theme-compatible
 // implementation. Only catalog registries and core shadcn resolve.
@@ -2132,7 +2127,7 @@ function startTunnel(port, onUrlChange, onOutput) {
 function requireAppDir(cmd) {
   const appDir = findAppRoot(process.cwd());
   if (!appDir) {
-    fail("NOT_A_MONTY_APP", `Not inside a Monty app. \`monty apps\` lists local apps; cd "$(monty select <slug>)" jumps to one — then run \`monty ${cmd}\`.`);
+    fail("NOT_A_MONTY_APP", `Not inside a Monty app. cd into the app's folder (\`monty connect <slug>\` pulls a copy into any folder), then run \`monty ${cmd}\`.`);
   }
   return appDir;
 }
@@ -2150,7 +2145,7 @@ function resolveComponent(name) {
   return name;
 }
 
-// ── monty add page <name> ──────────────────────────────────────────────────
+// ── monty page add <name> ──────────────────────────────────────────────────
 // Upgrades an app with a bespoke (custom) page: scaffolds the SPA on first
 // use (config-only apps gain src/ + vite from the template — their
 // monty.config.ts and AGENTS.md stay untouched), declares
@@ -2204,7 +2199,7 @@ async function declarePageThroughDoor(appDir, pageName) {
 
 async function addPage(appDir, pageName) {
   if (!pageName || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(pageName) || pageName.length > 32) {
-    fail("INVALID_PAGE", 'Usage: monty add page <name> — lowercase letters/digits with single hyphens, max 32 chars (e.g. "reports").');
+    fail("INVALID_PAGE", 'Usage: monty page add <name> — lowercase letters/digits with single hyphens, max 32 chars (e.g. "reports").');
   }
   const configPath = join(appDir, "monty.config.ts");
   if (!existsSync(configPath)) {
@@ -2291,7 +2286,7 @@ async function addPage(appDir, pageName) {
     if (existsSync(starter)) rmSync(starter);
     appendFileSync(
       join(appDir, "AGENTS.md"),
-      `\n---\n\n## Custom pages\n\nThis app now has a SPA half (src/) serving CUSTOM pages inside the\nplatform shell. Each page = a route in src/routes/ + a\n\`pages.<name>: { kind: "custom", path: "/<name>" }\` declaration.\nDECLARE-FIRST: \`monty add page <name>\` declares the entry (through the\nschema door on workspace-owned apps) before writing the route — a save\ncarrying an undeclared route refuses. System pages (table views) stay\nshell-rendered — only build bespoke UI here. \`monty dev\` serves both.\nAfter every meaningful change verified in dev, run\n\`monty save "<what changed>"\` — it pushes the work to the cloud copy,\nlike \`git push main\`.\n\nEvery custom page opens with \`PageHeader\` from \`@montytools/sdk/ui\` —\nthe same bar the shell renders on system pages (page actions go in it as\n\`PageHeaderButton\`s, \`primary\` for the one main action). Also there:\n\`FloatingBar\`/\`FloatingBarButton\` and the Lyra table classes\n\`SURFACE\`/\`THEAD\`/\`TH\`/\`ROW\`/\`CHIP\`.\n`,
+      `\n---\n\n## Custom pages\n\nThis app now has a SPA half (src/) serving CUSTOM pages inside the\nplatform shell. Each page = a route in src/routes/ + a\n\`pages.<name>: { kind: "custom", path: "/<name>" }\` declaration.\nDECLARE-FIRST: \`monty page add <name>\` declares the entry (through the\nschema door on workspace-owned apps) before writing the route — a save\ncarrying an undeclared route refuses. System pages (table views) stay\nshell-rendered — only build bespoke UI here. \`monty dev\` serves both.\nAfter every meaningful change verified in dev, run\n\`monty save "<what changed>"\` — it pushes the work to the cloud copy,\nlike \`git push main\`.\n\nEvery custom page opens with \`PageHeader\` from \`@montytools/sdk/ui\` —\nthe same bar the shell renders on system pages (page actions go in it as\n\`PageHeaderButton\`s, \`primary\` for the one main action). Also there:\n\`FloatingBar\`/\`FloatingBarButton\` and the Lyra table classes\n\`SURFACE\`/\`THEAD\`/\`TH\`/\`ROW\`/\`CHIP\`.\n`,
     );
   }
 
@@ -2372,16 +2367,17 @@ function pageComponentName(pageName) {
   return pageName.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join("") + "Page";
 }
 
-async function add() {
-  const appDir = requireAppDir("add");
-  const names = rest.filter((a) => !a.startsWith("--"));
-  if (names.length === 0) {
-    fail("NO_COMPONENT", "Usage: monty add <name...> — run `monty components` to see what's available (or `monty add page <name>` for a custom page).");
-  }
-  if (names[0] === "page") {
-    await addPage(appDir, names[1]);
-    return;
+// The page namespace: `monty page add <name>` scaffolds a bespoke page
+// (declare-first through the schema door).
+async function pageCmd() {
+  const [sub, name] = rest.filter((a) => !a.startsWith("--"));
+  if (sub !== "add") {
+    fail("INVALID_PAGE", 'Usage: monty page add <name> — scaffold a custom page (e.g. `monty page add reports`).');
   }
+  await addPage(requireAppDir("page"), name);
+}
+
+async function addComponents(appDir, names) {
   const items = names.flatMap((n) => [resolveComponent(n), ...(CATALOG[n]?.also ?? [])]);
 
   // --overwrite so shadcn never halts on a per-file prompt (an aborted prompt
@@ -2423,31 +2419,50 @@ async function add() {
   console.log(`added: ${items.join(", ")} -> src/components (already themed; import and compose)`);
 }
 
-function components() {
-  const query = rest.filter((a) => !a.startsWith("--")).join(" ").toLowerCase();
+// The component namespace: `monty components` lists/searches the curated
+// catalog, `components add <name...>` installs, `components docs <name>`
+// prints a component's source. (`search` is the explicit search subcommand;
+// a bare query searches too.)
+async function componentsCmd() {
+  const args = rest.filter((a) => !a.startsWith("--"));
+  const [sub, ...tail] = args;
+  if (sub === "add") {
+    if (tail.length === 0) {
+      fail("NO_COMPONENT", "Usage: monty components add <name...> — `monty components` lists the catalog; core shadcn components install by bare name.");
+    }
+    await addComponents(requireAppDir("components"), tail);
+    return;
+  }
+  if (sub === "docs") {
+    if (!tail[0]) {
+      fail("NO_COMPONENT", "Usage: monty components docs <name> — `monty components` lists the catalog.");
+    }
+    componentDocs(requireAppDir("components"), tail[0]);
+    return;
+  }
+  listComponents((sub === "search" ? tail : args).join(" ").toLowerCase());
+}
+
+function listComponents(query) {
   const entries = Object.entries(CATALOG).filter(
     ([name, { item, use }]) => !query || `${name} ${item} ${use}`.toLowerCase().includes(query),
   );
   const width = Math.max(...Object.keys(CATALOG).map((n) => n.length));
   const itemWidth = Math.max(...Object.values(CATALOG).map((c) => c.item.length));
-  console.log(`components: ${entries.length} curated (install with \`monty add <name>\`)`);
+  console.log(`components: ${entries.length} curated (install with \`monty components add <name>\`)`);
   for (const [name, { item, use }] of entries) {
     console.log(`  ${name.padEnd(width)}  ${item.padEnd(itemWidth)}  ${use}`);
   }
   console.log("core: any shadcn component installs by bare name (dialog, tabs, dropdown-menu, popover, tooltip, sheet, checkbox, textarea, ...)");
-  console.log("docs: `monty docs <name>` shows a component's source before installing");
+  console.log("docs: `monty components docs <name>` shows a component's source before installing");
 }
 
-async function docs() {
-  const appDir = requireAppDir("docs");
-  const name = rest.find((a) => !a.startsWith("--"));
-  if (!name) {
-    fail("NO_COMPONENT", "Usage: monty docs <name> — run `monty components` to see what's available.");
-  }
+function componentDocs(appDir, name) {
   run(appDir, "docs", ["pnpm", "dlx", "shadcn@latest", "view", resolveComponent(name)],
     `Could not view ${name}. Run \`monty components\` to see the curated catalog.`);
 }
 
+
 // ── monty secret ─────────────────────────────────────────────────────────
 // `monty secret set KEY [value]` / `monty secret rm KEY` — per-app
 // server-function secrets. The value goes to Cloudflare's per-script secrets
@@ -2455,12 +2470,11 @@ async function docs() {
 // readable back. Read from the arg, then a TTY prompt, then stdin (piping).
 async function secret() {
   const appDir = requireAppDir("secret");
-  // Identity comes from the stamp when it exists — no config compile for
-  // one slug read.
   const stamped = readAppJson(appDir);
-  const meta = typeof stamped?.slug === "string" && stamped.slug
-    ? { slug: stamped.slug }
-    : await compileConfig(appDir);
+  if (typeof stamped?.slug !== "string" || !stamped.slug) {
+    fail("NOT_CONNECTED", "This folder carries no app identity (.monty/app.json). Run `monty connect <slug>` here first.");
+  }
+  const meta = { slug: stamped.slug };
   const config = loadConfig();
   if (!config?.key) fail("NOT_LOGGED_IN", "Run `monty login` first.");
   const [sub, name] = rest.filter((a) => !a.startsWith("-"));
@@ -2498,10 +2512,11 @@ async function secret() {
 }
 
 // ── monty save ─────────────────────────────────────────────────────────────
-// Push the working copy to the cloud copy, like `git push main`. `deploy` is
-// the compat alias; both run the same pipeline (build + typecheck gate every
-// save, then one multipart POST). The optional message rides the deploy meta
-// so the platform can narrate the save later.
+// Push the working copy to the cloud copy, like `git push main` (build +
+// typecheck gate every save, then one multipart POST). A save ships
+// IMPLEMENTATION ONLY — the app's config lives in the workspace and lands
+// through the doors; the config file is never compiled here. The optional
+// message rides the meta so the platform can narrate the save later.
 async function deploy() {
   const appDir = requireAppDir(command);
   ensureSdk(appDir);
@@ -2521,40 +2536,36 @@ async function deploy() {
     fail("NOT_LOGGED_IN", "Run `monty login` first (create a key at /cli-auth in the Monty host).");
   }
 
-  // 1) Compile monty.config.ts → { slug, name, icon, schemaJson } using the
-  //    app's OWN zod/sdk instances (esbuild-bundled, run in a subprocess).
-  console.log("compile: monty.config.ts");
-  const meta = await compileConfig(appDir);
-  console.log(`compile: ok (app "${meta.slug}", ${Object.keys(meta.schemaJson.tables).length} tables)`);
+  // 1) Identity from the stamp; code-door declarations (publicFns,
+  //    schedule) are read literally from the config file, the same way the
+  //    vite plugin reads them.
+  const stamp = readAppJson(appDir);
+  if (typeof stamp?.slug !== "string" || !stamp.slug) {
+    fail("NOT_CONNECTED", "This folder carries no app identity (.monty/app.json). Run `monty connect <slug>` here to join an existing app, or `monty create <slug>` for a new one.");
+  }
+  const meta = {
+    slug: stamp.slug,
+    name: stamp.name ?? stamp.slug,
+    icon: stamp.icon,
+    publicFns: readPublicFnsLiteral(appDir),
+    schedule: readScheduleLiteral(appDir),
+  };
   // `monty save "what changed"` — the message rides the meta for the
   // platform to render as this save's Activity row.
   if (message) meta.message = message;
 
-  // Registry-owned apps ship IMPLEMENTATION ONLY: manifest, schema, rules,
-  // and exposure are door-owned (the server holds them regardless — not
-  // sending them keeps the wire honest). Code-door declarations
-  // (publicFns, schedule, pages, functions) still ride.
-  const registryOwned = readAppJson(appDir)?.registryOwned === true;
-  if (registryOwned) {
-    delete meta.schemaJson;
-    delete meta.manifest;
-    delete meta.exposure;
-    delete meta.rules;
-  }
-
-  // CONFIG-ONLY apps publish the manifest alone: no vite build, no bundle —
-  // the platform shell renders the app.
+  // CONFIG-ONLY apps have no bundle — the platform shell renders them; the
+  // save carries the source snapshot only.
   const configOnly = isConfigOnlyApp(appDir);
-  if (!configOnly) {
+  if (configOnly) {
+    meta.configOnly = true;
+  } else {
     // 2) Fail fast locally before any upload. Build FIRST — it also generates
     //    src/routeTree.gen.ts, without which tsc fails on a fresh checkout.
     run(appDir, "build", ["npx", "vite", "build"],
       "The production build failed. Read the vite error above; it names the file to fix.");
     run(appDir, "typecheck", ["npx", "tsc", "--noEmit"],
       "TypeScript errors above. Fix them in the listed files; `monty save` never uploads code that does not compile.");
-  } else if (!registryOwned && !meta.manifest) {
-    fail("MANIFEST_MISSING",
-      "This config-only app compiled without a manifest — that should be impossible (forceManifest). Re-run `monty install` to refresh the SDK, then retry.");
   }
 
   // 3) Multipart POST to the host.
@@ -2588,9 +2599,7 @@ async function deploy() {
           `schedule targets "${name}" but server/index.ts exports no such function. Export it (e.g. \`export async function ${name}(args, ctx) {…}\`) or remove the entry from monty.config.ts.`);
       }
     }
-    // Wire compat: meta.fns stays the UNION (older hosts gate dispatch on
-    // it); meta.datasets is the additive split newer hosts classify with.
-    meta.fns = [...serverBundle.fns, ...serverBundle.datasets];
+    if (serverBundle.fns.length > 0) meta.fns = serverBundle.fns;
     if (serverBundle.datasets.length > 0) meta.datasets = serverBundle.datasets;
     form.set("server-worker", new Blob([serverBundle.code]), "server-worker.mjs");
     const bundled = [];
@@ -2618,7 +2627,7 @@ async function deploy() {
   // only the minified bundle and the sole copy of the app's code is this
   // folder — delete it and the source is gone forever. The snapshot is what
   // `monty pull <slug>` restores on any machine, and the publish lands in
-  // the same version history as `monty commit`.
+  // the same version history as `monty save`.
   let sourceHash = null;
   {
     const packed = packSource(appDir);
@@ -2633,13 +2642,6 @@ async function deploy() {
       console.log(`source: ${(packed.buf.byteLength / 1024).toFixed(0)} KB snapshot rides this save (restore anywhere: monty pull ${meta.slug})`);
     }
   }
-  // V2 schema CAS: prove which stored manifest this checkout last synced,
-  // so an API/MCP edit made meanwhile surfaces as MANIFEST_DRIFT instead of
-  // being clobbered (fix: `monty schema pull`).
-  if (meta.manifest !== undefined) {
-    const state = readSchemaState(appDir);
-    if (state?.hash) meta.baseManifestHash = state.hash;
-  }
   form.set("monty", JSON.stringify(meta));
   let total = 0;
   for (const file of files) {
@@ -2650,7 +2652,7 @@ async function deploy() {
   }
   console.log(
     configOnly
-      ? `upload: config-only (manifest, no bundle) -> ${config.host}/api/deploy`
+      ? `upload: config-only (source snapshot, no bundle) -> ${config.host}/api/deploy`
       : `upload: ${files.length} files, ${(total / 1024).toFixed(0)} KB -> ${config.host}/api/deploy`,
   );
   const res = await fetch(`${config.host}/api/deploy`, {
@@ -2660,22 +2662,10 @@ async function deploy() {
   });
   const body = await res.json().catch(() => null);
   if (!res.ok || !body?.ok) {
-    if (body?.code === "MANIFEST_DRIFT" && body?.summary) {
-      console.log(`schema drift (remote changes):\n${body.summary}`);
-    }
     fail(body?.code ?? `HTTP_${res.status}`, body?.fix ?? "Unexpected server response — is the Monty host reachable?");
   }
   console.log(`origin: ${body.origin}`);
   console.log(`saved: ${body.url} (version ${body.version})`);
-  if (body.manifestDrift) {
-    // The code shipped; the config was HELD — the stored schema changed
-    // since this checkout last synced (another editor).
-    console.log(`schema drift (remote changes):${body.manifestDrift.summary ? `\n${body.manifestDrift.summary}` : ""}`);
-    console.log(`config push held: ${body.manifestDrift.fix ?? "Run `monty schema pull`, merge, then deploy again."}`);
-  } else if (meta.manifest !== undefined) {
-    // The manifest just published IS the new CAS base.
-    writeSchemaState(appDir, manifestHash(meta.manifest));
-  }
   // Stamp what was published — pull uses this to tell "unchanged since last
   // sync" from "locally modified".
   if (sourceHash) {
@@ -2777,25 +2767,6 @@ function discoverFnExports(serverEntry) {
   return [...names];
 }
 
-// Thin wrapper over the shared pipeline (lib/compile.mjs): `soft` keeps the
-// the session heartbeat's last good schema through transient config breakage.
-async function compileConfig(appDir, { soft = false } = {}) {
-  try {
-    // Config-only apps (no SPA) always compile a manifest: the platform
-    // shell is their only renderer.
-    return await compileAppConfig(appDir, { forceManifest: isConfigOnlyApp(appDir) });
-  } catch (e) {
-    if (e instanceof CompileError) {
-      if (soft) {
-        console.log("schema: monty.config.ts doesn't compile right now — keeping the last good schema");
-        return null;
-      }
-      fail(e.code, e.fix);
-    }
-    throw e;
-  }
-}
-
 function run(cwd, label, argv, fixOnFail) {
   console.log(`${label}: ${argv.join(" ")}`);
   // stdin ignored: interactive prompts (e.g. shadcn's per-file overwrite
@@ -2917,10 +2888,7 @@ function resolveDataApp() {
   const root = findAppRoot(process.cwd());
   const slug = explicit ?? (root ? readSlugFromConfig(root) : null);
   if (!slug) {
-    fail("NO_APP", "Say which app: pass --app <slug>, or run inside an app folder. `monty apps` lists local apps.");
-  }
-  if (rest.includes("--studio")) {
-    fail("STUDIO_REMOVED", "The session sandbox is gone — every app has one set of records, and data verbs always target it. Drop --studio.");
+    fail("NO_APP", "Say which app: pass --app <slug>, or run inside an app folder.");
   }
   return slug;
 }
@@ -3056,33 +3024,17 @@ async function data() {
   const [verb, table, id] = dataPositionals();
 
   if (verb === "schema") {
-    // Shape comes from the LOCAL source checkout (compiled through the real
-    // pipeline) — the same monty.config.ts that defines what the app stores.
-    const explicit = flag("app");
-    const root = explicit
-      ? (listLocalApps().find((a) => a.slug === explicit || a.id === explicit)?.path ?? null)
-      : findAppRoot(process.cwd());
-    if (!root) {
-      fail("APP_NOT_LOCAL", explicit
-        ? `No local source for "${explicit}" on this machine — run \`monty pull ${explicit}\` first, or cd into the app folder.`
-        : "Not inside an app folder. Pass --app <slug> (needs the source pulled locally) or cd into the app.");
-    }
-    let meta;
-    try {
-      meta = await compileAppConfig(root);
-    } catch (e) {
-      if (e instanceof CompileError) fail(e.code, e.fix);
-      throw e;
-    }
-    const tables = meta.schemaJson?.tables ?? {};
-    if (table !== undefined) {
-      if (!tables[table]) {
-        fail("NO_SUCH_TABLE", `App "${meta.slug}" has no table "${table}". Tables: ${Object.keys(tables).join(", ") || "(none)"}.`);
-      }
-      printJson({ app: meta.slug, table, schema: tables[table] });
-    } else {
-      printJson({ app: meta.slug, tables });
-    }
+    // Shape comes from the WORKSPACE — the stored schema the platform
+    // validates against (derived from the app's config).
+    const app = resolveDataApp();
+    const auth = await workspaceAuth();
+    const result = await callRecords(
+      "query",
+      "schema",
+      table !== undefined ? { app, table } : { app },
+      auth,
+    );
+    printJson({ app, ...result });
     return;
   }
 
@@ -3267,7 +3219,7 @@ async function data() {
 // 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"]);
+const VIEW_VALUE_FLAGS = new Set(["app", "filter", "sort", "hide", "name", "kanban"]);
 
 function viewPositionals() {
   const out = [];
@@ -3285,10 +3237,11 @@ function viewPositionals() {
 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("  set    <table> <name> [--filter '<json>'] [--sort field:asc|desc] [--hide field,...] [--kanban field|none] [--app slug]");
+  console.log("  update <table> <name> [--name new-name] [--filter '<json>'] [--sort field:asc|desc|none] [--hide field,...] [--kanban field|none] [--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("kanban: the view renders as lanes over the select field's values; \"none\" makes it a table");
   console.log("example: monty views set leads \"Evaluate\" --filter '{\"pipelineId\":null}'");
   process.exit(1);
 }
@@ -3313,10 +3266,9 @@ function viewName(input) {
 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.`);
-  }
+  // Nothing stored yet is just an empty config — the table lookup below
+  // says what's actually missing.
+  const manifest = (await callConvex("query", "platform:appManifest", { slug: app }, auth)) ?? { tables: {} };
   const tableSpec = manifest.tables?.[table];
   if (!tableSpec) {
     fail("NO_SUCH_TABLE", `App "${app}" has no table "${table}". Tables: ${Object.keys(manifest.tables ?? {}).join(", ") || "(none)"}.`);
@@ -3343,6 +3295,8 @@ function requestedViewConfig(fields) {
       sort: parseViewSort(flag("sort")),
       hidden: parseHiddenColumns(flag("hide")),
     };
+    const kanban = parseKanbanFlag(flag("kanban"));
+    if (kanban) Object.assign(config, kanban);
     return validateViewColumns(config, fields);
   } catch (error) {
     fail(error?.code ?? "BAD_VIEW_CONFIG", error?.fix ?? error?.message ?? "The saved view config is invalid.");
@@ -3355,6 +3309,7 @@ function requestedViewPatch() {
       ...(rest.includes("--filter") ? { filters: normalizeViewFilters(parseJsonFlag("filter")) } : {}),
       ...(rest.includes("--sort") ? { sort: parseViewSort(flag("sort")) } : {}),
       ...(rest.includes("--hide") ? { hidden: parseHiddenColumns(flag("hide")) } : {}),
+      ...(rest.includes("--kanban") ? { kanban: parseKanbanFlag(flag("kanban")) } : {}),
     };
   } catch (error) {
     fail(error?.code ?? "BAD_VIEW_CONFIG", error?.fix ?? error?.message ?? "The saved view config is invalid.");
@@ -3405,7 +3360,7 @@ async function views() {
     }
     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.");
+      fail("NO_VIEW_CHANGES", "Provide --name, --filter, --sort, --hide, or --kanban. Omitted properties stay unchanged.");
     }
     const config = checkedViewConfig(mergeViewConfig(existing.config, patch), fields);
     await callConvex("mutation", "platform:saveView", { app, page: table, name: nextName, config }, auth);
@@ -3635,7 +3590,7 @@ if (command !== "dev" && command !== "logs" && command !== "support") {
 // The app's data half (tables, field algebra, metrics, settings, pages)
 // lives ONLY in the workspace. `monty schema [slug]` prints the stored
 // manifest as JSON (and stamps the CAS base); edit that JSON and
-// `monty schema set <file|->` writes it back through the one landing —
+// `monty schema set '<json>'` (or `set -` piped) writes it back|->` writes it back through the one landing —
 // validated server-side, additive-only by default, CAS against what you
 // read. `monty schema pull` (legacy) regenerates monty.config.ts.
 async function schemaCmd() {
@@ -3664,24 +3619,28 @@ async function schemaCmd() {
   }
 
   if (verb === "set") {
+    // The config is passed as JSON, never a file — nothing to leave behind
+    // in the app folder. `-` reads stdin for configs too big for an arg.
     const target = rest[1];
     if (!target) {
-      fail("SCHEMA_USAGE", "Usage: monty schema set <file.json|-> [--allow-breaking] — the JSON is a full manifest (start from `monty schema`).");
+      fail("SCHEMA_USAGE", "Usage: monty schema set '<json>' [--allow-breaking] — the app's full config as JSON (start from `monty schema`; pipe with `monty schema set -`).");
     }
-    let raw;
-    try {
-      raw = target === "-" ? readFileSync(0, "utf8") : readFileSync(target, "utf8");
-    } catch {
-      fail("SCHEMA_USAGE", `Could not read ${target === "-" ? "stdin" : target}. Pass a manifest JSON file, or - for stdin.`);
+    let raw = target;
+    if (target === "-") {
+      try {
+        raw = readFileSync(0, "utf8");
+      } catch {
+        fail("SCHEMA_USAGE", "Could not read stdin. Pipe the config JSON in: `monty schema | <edit> | monty schema set -`.");
+      }
     }
     let manifest;
     try {
       manifest = JSON.parse(raw);
     } catch {
-      fail("BAD_MANIFEST_JSON", "That is not valid JSON. Start from `monty schema` output, edit, and set the whole document back.");
+      fail("BAD_CONFIG_JSON", "That is not valid JSON. Pass the whole config as one JSON argument (start from `monty schema` output), or pipe it with `monty schema set -`.");
     }
     const slug = typeof manifest?.slug === "string" && manifest.slug ? manifest.slug : (appDir ? readSlug(appDir) : null);
-    if (!slug) fail("INVALID_SLUG", "The manifest carries no slug and this is not an app folder — set `slug` in the JSON.");
+    if (!slug) fail("INVALID_SLUG", "The config carries no slug and this is not an app folder — set `slug` in the JSON.");
     // CAS: prove which stored manifest this edit was based on (stamped by
     // the last `monty schema` read in this folder). Absent = trusting push.
     const base = appDir && readSlug(appDir) === slug ? readSchemaState(appDir)?.hash : undefined;
@@ -3700,7 +3659,7 @@ async function schemaCmd() {
       if (body?.code === "MANIFEST_DRIFT" && body?.summary) {
         console.log(`schema drift (remote changes):\n${body.summary}`);
       }
-      fail(body?.code ?? `HTTP_${res.status}`, body?.fix ?? "Setting the manifest failed — is the Monty host reachable?");
+      fail(body?.code ?? `HTTP_${res.status}`, body?.fix ?? "Setting the config failed — is the Monty host reachable?");
     }
     if (appDir && readSlug(appDir) === slug) writeSchemaState(appDir, body.hash);
     console.log(`schema: set — "${slug}" is live now (hash ${String(body.hash).slice(0, 12)})`);
@@ -3708,7 +3667,7 @@ async function schemaCmd() {
   }
 
   // Default: SHOW. `monty schema [slug]` — stdout is the pure manifest
-  // JSON (pipe it to a file, edit, `monty schema set` it back).
+  // JSON (edit it, then `monty schema set` the whole document back).
   const slug = (verb && !verb.startsWith("-") ? verb : null) ?? (appDir ? readSlug(appDir) : null);
   if (!slug) fail("INVALID_SLUG", "Usage: monty schema [slug] — or run it inside an app folder.");
   const res = await fetch(`${host}/api/schema?slug=${slug}`, {
@@ -3716,13 +3675,17 @@ async function schemaCmd() {
   });
   const body = await res.json().catch(() => null);
   if (!res.ok || !body?.ok) {
-    fail(body?.code ?? `HTTP_${res.status}`, body?.fix ?? "Could not read the manifest — check the connection and `monty login`.");
+    fail(body?.code ?? `HTTP_${res.status}`, body?.fix ?? "Could not read the config — check the connection and `monty login`.");
   }
   if (body.manifest === null) {
-    fail("NO_MANIFEST", `"${slug}" has no stored manifest yet — it's a code-only app. Declare one by setting a full manifest JSON: monty schema set <file>.`);
+    // Nothing stored yet is just an empty config — hand it back so the
+    // agent can fill it in and `monty schema set` it.
+    console.error(`# ${slug} — empty config (nothing stored yet; "monty schema set" declares it)`);
+    console.log(JSON.stringify({ slug, tables: {} }, null, 2));
+    return;
   }
   if (appDir && readSlug(appDir) === slug) writeSchemaState(appDir, body.hash);
-  console.error(`# ${slug} — manifest hash ${String(body.hash).slice(0, 12)}${appDir ? " (CAS base stamped for `monty schema set`)" : ""}`);
+  console.error(`# ${slug} — config hash ${String(body.hash).slice(0, 12)}${appDir ? " (CAS base stamped for `monty schema set`)" : ""}`);
   console.log(JSON.stringify(body.manifest, null, 2));
 }
 
@@ -3733,41 +3696,30 @@ switch (command) {
   case "create":
     await create();
     break;
+  case "connect":
+    await connect();
+    break;
   case "pull":
     await pull();
     break;
-  case "commit":
-    fail("COMMIT_REMOVED", "`monty commit` is gone — `monty save` is the one verb (every save records a history row; `monty log` lists them).");
-    break;
-  case "log":
-  case "versions":
+  case "history":
     await versionsLog();
     break;
+  case "page":
+    await pageCmd();
+    break;
   case "dev":
     await dev();
     break;
   case "logs":
     await logs();
     break;
-  case "add":
-    await add();
-    break;
   case "components":
-  case "search":
-    components();
-    break;
-  case "docs":
-    await docs();
+    await componentsCmd();
     break;
   case "current":
     current();
     break;
-  case "select":
-    select();
-    break;
-  case "apps":
-    apps();
-    break;
   case "skills":
     installSkills({ appDir: findAppRoot(process.cwd()), silent: false, force: true });
     console.log("skills: up to date");
@@ -3782,7 +3734,6 @@ switch (command) {
     typecheckApp();
     break;
   case "save":
-  case "deploy":
     await deploy();
     break;
   case "data":
@@ -3800,29 +3751,42 @@ switch (command) {
   case "secret":
     await secret();
     break;
+  case "help":
+  case "--help":
+  case "-h":
+    printHelp();
+    process.exit(0);
+    break;
   default:
-    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`)");
-    console.log("  log         [slug]                          the app's source version history (one row per save)");
-    console.log("  dev         [--port N] [--no-tunnel] [--takeover]  run the app's session, or attach to a running one (live data, auto-auth)");
-    console.log("  logs        [-n N] [-f]                     read/follow the dev shell log (vite output, browser errors, save results)");
-    console.log("  add         <name...> | page <name>         install UI components, or scaffold a custom page (`monty add page reports`)");
-    console.log("  components  [query]                        list the curated component catalog");
-    console.log("  docs        <name>                         view a component's source before installing");
-    console.log("  current                                     which app folder am I in?");
-    console.log("  select      <slug>                          print an app's folder — cd \"$(monty select x)\"");
-    console.log("  apps                                        list local apps (~/.monty/apps + legacy ~/Monty)");
-    console.log("  install                                     install app dependencies");
-    console.log("  build                                       production build (vite, via monty)");
-    console.log("  typecheck                                   typecheck (builds first if needed)");
-    console.log("  save        [\"what changed\"]                 push the working copy to the cloud copy, like `git push main` (build + typecheck gate it)");
-    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");
+    printHelp();
     process.exit(command ? 1 : 0);
 }
+
+function printHelp() {
+  console.log("usage: monty <command>  (`monty help` shows this)");
+  console.log("");
+  console.log("start here:");
+  console.log("  login       [--host <url>]                   sign in (opens your browser to authorize)");
+  console.log("  connect     <slug> [dir]                     pull a cloud app into any folder, ready for `monty dev`");
+  console.log("  create      <slug> [--name N] [--spa]        register a brand-new app (config-only by default)");
+  console.log("  dev         [--port N] [--takeover]          run the app's session — live data, the workspace follows it");
+  console.log("  save        [\"what changed\"]                  push the working copy to the cloud copy, like `git push main`");
+  console.log("  logs        [-n N] [-f]                      read/follow the running session's log");
+  console.log("");
+  console.log("toolbelt:");
+  console.log("  current                                      which app folder am I in?");
+  console.log("  history     [slug]                           saved-version history, one row per save (like `git log`)");
+  console.log("  pull        <slug> [--version H] [--force]   restore a source snapshot into the managed home");
+  console.log("  install / build / typecheck                  app lifecycle (pnpm/npm picked for you)");
+  console.log("  data        <verb> [table] [flags]           read/write an app's records from the terminal");
+  console.log("  schema      [slug] | set <json|->              read/write the app's config, stored in the workspace (validated, CAS)");
+  console.log("  views       <list|set|update|remove> <table>  manage shared saved views on a record page");
+  console.log("  secret      <set|rm> <KEY>                   per-app server-function secrets (write-only)");
+  console.log("  support     <status|enable|disable|submit>    opt in to agent-authored platform reports");
+  console.log("  skills                                       install/refresh the agent build skill");
+  console.log("");
+  console.log("custom pages & components (apps with src/):");
+  console.log("  page        add <name>                       scaffold a custom (bespoke) page");
+  console.log("  components  [query] | search <q>             the curated shadcn catalog — list or search it");
+  console.log("  components  add <name...> | docs <name>      install curated components / read one's source first");
+}