@objectstack/cli 1.0.11 → 1.0.12

package/dist/bin.js

@@ -1,29 +1,327 @@
 #!/usr/bin/env node
-import {
-  compileCommand
-} from "./chunk-2YXVEYO7.js";
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/bin.ts
 import { createRequire } from "module";
-import { Command as Command6 } from "commander";
+import { Command as Command12 } from "commander";
+import chalk13 from "chalk";
 
-// src/commands/dev.ts
+// src/commands/compile.ts
 import { Command } from "commander";
-import chalk from "chalk";
-import { execSync, spawn } from "child_process";
-import fs from "fs";
+import path2 from "path";
+import fs2 from "fs";
+import chalk3 from "chalk";
+import { ObjectStackDefinitionSchema } from "@objectstack/spec";
+
+// src/utils/config.ts
 import path from "path";
-var devCommand = new Command("dev").description("Start development mode for a package").argument("[package]", "Package name or filter pattern", "all").option("-w, --watch", "Enable watch mode (default)", true).option("-v, --verbose", "Verbose output").action(async (packageName, options) => {
+import fs from "fs";
+import chalk2 from "chalk";
+import { bundleRequire } from "bundle-require";
+
+// src/utils/format.ts
+import chalk from "chalk";
+function printHeader(title) {
   console.log(chalk.bold(`
-\u{1F680} ObjectStack Development Mode`));
-  console.log(chalk.dim(`-------------------------------`));
-  const configPath = path.resolve(process.cwd(), "objectstack.config.ts");
-  if (packageName === "all" && fs.existsSync(configPath)) {
-    console.log(chalk.blue(`\u{1F4C2} Detected package config: ${configPath}`));
-    console.log(chalk.green(`\u26A1 Starting Dev Server...`));
+\u25C6 ${title}`));
+  console.log(chalk.dim("\u2500".repeat(40)));
+}
+function printKV(key, value, icon) {
+  const prefix = icon ? `${icon} ` : "  ";
+  console.log(`${prefix}${chalk.dim(key + ":")} ${chalk.white(String(value))}`);
+}
+function printSuccess(msg) {
+  console.log(chalk.green(`  \u2713 ${msg}`));
+}
+function printWarning(msg) {
+  console.log(chalk.yellow(`  \u26A0 ${msg}`));
+}
+function printError(msg) {
+  console.log(chalk.red(`  \u2717 ${msg}`));
+}
+function printInfo(msg) {
+  console.log(chalk.blue(`  \u2139 ${msg}`));
+}
+function printStep(msg) {
+  console.log(chalk.yellow(`  \u2192 ${msg}`));
+}
+function createTimer() {
+  const start = Date.now();
+  return {
+    elapsed: () => Date.now() - start,
+    display: () => `${Date.now() - start}ms`
+  };
+}
+function formatZodErrors(error) {
+  const issues = error.issues || error.errors || [];
+  if (issues.length === 0) {
+    console.log(chalk.red("  Unknown validation error"));
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const topPath = issue.path?.[0] || "_root";
+    if (!grouped.has(String(topPath))) {
+      grouped.set(String(topPath), []);
+    }
+    grouped.get(String(topPath)).push(issue);
+  }
+  for (const [section, sectionIssues] of grouped) {
+    console.log(chalk.bold.red(`
+  ${section}:`));
+    for (const issue of sectionIssues) {
+      const path11 = issue.path?.join(".") || "";
+      const code = issue.code || "";
+      const msg = issue.message || "";
+      console.log(chalk.red(`    \u2717 ${path11}`));
+      console.log(chalk.dim(`      ${code}: ${msg}`));
+      if (issue.expected) {
+        console.log(chalk.dim(`      expected: ${chalk.green(issue.expected)}`));
+      }
+      if (issue.received) {
+        console.log(chalk.dim(`      received: ${chalk.red(issue.received)}`));
+      }
+    }
+  }
+  console.log("");
+  console.log(chalk.dim(`  ${issues.length} validation error(s) total`));
+}
+function collectMetadataStats(config) {
+  const count = (arr) => Array.isArray(arr) ? arr.length : 0;
+  let fields = 0;
+  if (Array.isArray(config.objects)) {
+    for (const obj of config.objects) {
+      if (obj.fields && typeof obj.fields === "object") {
+        fields += Object.keys(obj.fields).length;
+      }
+    }
+  }
+  return {
+    objects: count(config.objects),
+    objectExtensions: count(config.objectExtensions),
+    fields,
+    views: count(config.views),
+    pages: count(config.pages),
+    apps: count(config.apps),
+    dashboards: count(config.dashboards),
+    reports: count(config.reports),
+    actions: count(config.actions),
+    flows: count(config.flows),
+    workflows: count(config.workflows),
+    approvals: count(config.approvals),
+    agents: count(config.agents),
+    apis: count(config.apis),
+    roles: count(config.roles),
+    permissions: count(config.permissions),
+    themes: count(config.themes),
+    datasources: count(config.datasources),
+    translations: count(config.translations),
+    plugins: count(config.plugins),
+    devPlugins: count(config.devPlugins)
+  };
+}
+function printServerReady(opts) {
+  const base = `http://localhost:${opts.port}`;
+  console.log("");
+  console.log(chalk.bold.green("  \u2713 Server is ready"));
+  console.log("");
+  console.log(chalk.cyan("  \u279C") + chalk.bold("  API:     ") + chalk.cyan(base + "/"));
+  if (opts.uiEnabled && opts.studioPath) {
+    console.log(chalk.cyan("  \u279C") + chalk.bold("  Console: ") + chalk.cyan(base + opts.studioPath + "/"));
+  }
+  console.log("");
+  console.log(chalk.dim(`  Config:  ${opts.configFile}`));
+  console.log(chalk.dim(`  Mode:    ${opts.isDev ? "development" : "production"}`));
+  console.log(chalk.dim(`  Plugins: ${opts.pluginCount} loaded`));
+  if (opts.pluginNames && opts.pluginNames.length > 0) {
+    console.log(chalk.dim(`           ${opts.pluginNames.join(", ")}`));
+  }
+  console.log("");
+  console.log(chalk.dim("  Press Ctrl+C to stop"));
+  console.log("");
+}
+function printMetadataStats(stats) {
+  const sections = [
+    {
+      label: "Data",
+      items: [
+        ["Objects", stats.objects],
+        ["Fields", stats.fields],
+        ["Extensions", stats.objectExtensions],
+        ["Datasources", stats.datasources]
+      ]
+    },
+    {
+      label: "UI",
+      items: [
+        ["Apps", stats.apps],
+        ["Views", stats.views],
+        ["Pages", stats.pages],
+        ["Dashboards", stats.dashboards],
+        ["Reports", stats.reports],
+        ["Actions", stats.actions],
+        ["Themes", stats.themes]
+      ]
+    },
+    {
+      label: "Logic",
+      items: [
+        ["Flows", stats.flows],
+        ["Workflows", stats.workflows],
+        ["Approvals", stats.approvals],
+        ["Agents", stats.agents],
+        ["APIs", stats.apis]
+      ]
+    },
+    {
+      label: "Security",
+      items: [
+        ["Roles", stats.roles],
+        ["Permissions", stats.permissions]
+      ]
+    }
+  ];
+  for (const section of sections) {
+    const nonZero = section.items.filter(([, v]) => v > 0);
+    if (nonZero.length === 0) continue;
+    const line = nonZero.map(([k, v]) => `${chalk.white(v)} ${chalk.dim(k)}`).join("  ");
+    console.log(`  ${chalk.bold(section.label + ":")} ${line}`);
+  }
+  if (stats.plugins > 0 || stats.devPlugins > 0) {
+    const parts = [];
+    if (stats.plugins > 0) parts.push(`${stats.plugins} plugins`);
+    if (stats.devPlugins > 0) parts.push(`${stats.devPlugins} devPlugins`);
+    console.log(`  ${chalk.bold("Runtime:")} ${chalk.dim(parts.join(", "))}`);
+  }
+}
+
+// src/utils/config.ts
+function resolveConfigPath(source) {
+  if (source) {
+    const abs = path.resolve(process.cwd(), source);
+    if (!fs.existsSync(abs)) {
+      printError(`Config file not found: ${chalk2.white(abs)}`);
+      console.log("");
+      console.log(chalk2.dim("  Hint: Run this command from a directory with objectstack.config.ts"));
+      console.log(chalk2.dim("  Or specify the path: objectstack <command> path/to/config.ts"));
+      process.exit(1);
+    }
+    return abs;
+  }
+  const candidates = [
+    "objectstack.config.ts",
+    "objectstack.config.js",
+    "objectstack.config.mjs"
+  ];
+  for (const candidate of candidates) {
+    const abs = path.resolve(process.cwd(), candidate);
+    if (fs.existsSync(abs)) return abs;
+  }
+  printError("No objectstack.config.{ts,js,mjs} found in current directory");
+  console.log("");
+  console.log(chalk2.dim("  Hint: Run `objectstack init` to create a new project"));
+  process.exit(1);
+}
+async function loadConfig(source) {
+  const absolutePath = resolveConfigPath(source);
+  const start = Date.now();
+  const { mod } = await bundleRequire({
+    filepath: absolutePath
+  });
+  const config = mod.default || mod;
+  if (!config) {
+    throw new Error(`No default export found in ${path.basename(absolutePath)}`);
+  }
+  return {
+    config,
+    absolutePath,
+    duration: Date.now() - start
+  };
+}
+
+// src/commands/compile.ts
+var compileCommand = new Command("compile").description("Compile ObjectStack configuration to JSON artifact").argument("[config]", "Source configuration file").option("-o, --output <path>", "Output JSON file", "dist/objectstack.json").option("--json", "Output compile result as JSON (for CI)").action(async (configPath, options) => {
+  const timer = createTimer();
+  if (!options.json) {
+    printHeader("Compile");
+  }
+  try {
+    if (!options.json) printStep("Loading configuration...");
+    const { config, absolutePath, duration } = await loadConfig(configPath);
+    if (!options.json) {
+      printKV("Config", path2.relative(process.cwd(), absolutePath));
+      printKV("Load time", `${duration}ms`);
+    }
+    if (!options.json) printStep("Validating protocol compliance...");
+    const result = ObjectStackDefinitionSchema.safeParse(config);
+    if (!result.success) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, errors: result.error.issues }));
+        process.exit(1);
+      }
+      console.log("");
+      printError("Validation failed");
+      formatZodErrors(result.error);
+      process.exit(1);
+    }
+    if (!options.json) printStep("Writing artifact...");
+    const output = options.output;
+    const artifactPath = path2.resolve(process.cwd(), output);
+    const artifactDir = path2.dirname(artifactPath);
+    if (!fs2.existsSync(artifactDir)) {
+      fs2.mkdirSync(artifactDir, { recursive: true });
+    }
+    const jsonContent = JSON.stringify(result.data, null, 2);
+    fs2.writeFileSync(artifactPath, jsonContent);
+    const sizeKB = (jsonContent.length / 1024).toFixed(1);
+    const stats = collectMetadataStats(config);
+    if (options.json) {
+      console.log(JSON.stringify({
+        success: true,
+        output: artifactPath,
+        size: jsonContent.length,
+        stats,
+        duration: timer.elapsed()
+      }));
+      return;
+    }
+    console.log("");
+    printSuccess(`Build complete ${chalk3.dim(`(${timer.display()})`)}`);
+    console.log("");
+    printMetadataStats(stats);
+    console.log("");
+    printKV("Artifact", `${output} ${chalk3.dim(`(${sizeKB} KB`)})`);
+    console.log("");
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: error.message }));
+      process.exit(1);
+    }
     console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/dev.ts
+import { Command as Command2 } from "commander";
+import chalk4 from "chalk";
+import { execSync, spawn } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+var devCommand = new Command2("dev").description("Start development mode with hot-reload").argument("[package]", "Package name or filter pattern", "all").option("-w, --watch", "Enable watch mode (default)", true).option("--ui", "Enable Console UI at /_studio/").option("-v, --verbose", "Verbose output").action(async (packageName, options) => {
+  printHeader("Development Mode");
+  const configPath = path3.resolve(process.cwd(), "objectstack.config.ts");
+  if (packageName === "all" && fs3.existsSync(configPath)) {
+    printKV("Config", configPath, "\u{1F4C2}");
+    printStep("Starting dev server...");
     const binPath = process.argv[1];
-    const child = spawn(process.execPath, [binPath, "serve", "--dev", ...options.verbose ? ["--verbose"] : []], {
+    const child = spawn(process.execPath, [binPath, "serve", "--dev", ...options.ui ? ["--ui"] : [], ...options.verbose ? ["--verbose"] : []], {
       stdio: "inherit",
       env: { ...process.env, NODE_ENV: "development" }
     });
@@ -31,45 +329,37 @@ var devCommand = new Command("dev").description("Start development mode for a pa
   }
   try {
     const cwd = process.cwd();
-    const workspaceConfigPath = path.resolve(cwd, "pnpm-workspace.yaml");
-    const isWorkspaceRoot = fs.existsSync(workspaceConfigPath);
+    const workspaceConfigPath = path3.resolve(cwd, "pnpm-workspace.yaml");
+    const isWorkspaceRoot = fs3.existsSync(workspaceConfigPath);
     if (packageName === "all" && !isWorkspaceRoot) {
-      console.error(chalk.red(`
-\u274C Configuration file (objectstack.config.ts) not found in ${cwd}`));
-      console.error(chalk.yellow(`   To start development mode, run this command in a directory with objectstack.config.ts`));
-      console.error(chalk.yellow(`   OR run from the monorepo root to start all packages.`));
+      printError(`Config file not found in ${cwd}`);
+      console.error(chalk4.yellow("  Run in a directory with objectstack.config.ts, or from the monorepo root."));
       process.exit(1);
     }
     const filter = packageName === "all" ? "" : `--filter ${packageName}`;
-    console.log(`\u{1F4E6} Package: ${chalk.blue(packageName === "all" ? "All packages" : packageName)}`);
-    console.log(`\u{1F504} Watch mode: ${chalk.green("enabled")}`);
-    console.log("");
+    printKV("Package", packageName === "all" ? "All packages" : packageName, "\u{1F4E6}");
+    printKV("Watch", "enabled", "\u{1F504}");
     const command = `pnpm ${filter} dev`.trim();
-    console.log(chalk.dim(`$ ${command}`));
+    console.log(chalk4.dim(`$ ${command}`));
     console.log("");
     execSync(command, {
       stdio: "inherit",
       cwd
     });
   } catch (error) {
-    console.error(chalk.red(`
-\u274C Development mode failed:`));
-    console.error(error.message || error);
+    printError(`Development mode failed: ${error.message || error}`);
     process.exit(1);
   }
 });
 
 // src/commands/doctor.ts
-import { Command as Command2 } from "commander";
-import chalk2 from "chalk";
+import { Command as Command3 } from "commander";
+import chalk5 from "chalk";
 import { execSync as execSync2 } from "child_process";
-import fs2 from "fs";
-import path2 from "path";
-var doctorCommand = new Command2("doctor").description("Check development environment health").option("-v, --verbose", "Show detailed information").action(async (options) => {
-  console.log(chalk2.bold(`
-\u{1F3E5} ObjectStack Environment Health Check`));
-  console.log(chalk2.dim(`-----------------------------------------`));
-  console.log("");
+import fs4 from "fs";
+import path4 from "path";
+var doctorCommand = new Command3("doctor").description("Check development environment health").option("-v, --verbose", "Show detailed information").action(async (options) => {
+  printHeader("Environment Health Check");
   const results = [];
   try {
     const nodeVersion = process.version;
@@ -127,8 +417,8 @@ var doctorCommand = new Command2("doctor").description("Check development enviro
     });
   }
   const cwd = process.cwd();
-  const nodeModulesPath = path2.join(cwd, "node_modules");
-  if (fs2.existsSync(nodeModulesPath)) {
+  const nodeModulesPath = path4.join(cwd, "node_modules");
+  if (fs4.existsSync(nodeModulesPath)) {
     results.push({
       name: "Dependencies",
       status: "ok",
@@ -142,8 +432,8 @@ var doctorCommand = new Command2("doctor").description("Check development enviro
       fix: "Run: pnpm install"
     });
   }
-  const specDistPath = path2.join(cwd, "packages/spec/dist");
-  if (fs2.existsSync(specDistPath)) {
+  const specDistPath = path4.join(cwd, "packages/spec/dist");
+  if (fs4.existsSync(specDistPath)) {
     results.push({
       name: "@objectstack/spec",
       status: "ok",
@@ -174,35 +464,41 @@ var doctorCommand = new Command2("doctor").description("Check development enviro
   }
   let hasErrors = false;
   let hasWarnings = false;
+  console.log("");
   results.forEach((result) => {
-    const icon = result.status === "ok" ? "\u2713" : result.status === "warning" ? "\u26A0" : "\u2717";
-    const color = result.status === "ok" ? chalk2.green : result.status === "warning" ? chalk2.yellow : chalk2.red;
-    console.log(color(`${icon} ${result.name.padEnd(20)} ${result.message}`));
-    if (result.fix && options.verbose) {
-      console.log(chalk2.dim(`  \u2192 ${result.fix}`));
+    const padded = result.name.padEnd(20);
+    if (result.status === "ok") {
+      printSuccess(`${padded} ${result.message}`);
+    } else if (result.status === "warning") {
+      printWarning(`${padded} ${result.message}`);
+    } else {
+      printError(`${padded} ${result.message}`);
+    }
+    if (result.fix && (options.verbose || result.status === "error")) {
+      console.log(chalk5.dim(`      \u2192 ${result.fix}`));
     }
     if (result.status === "error") hasErrors = true;
     if (result.status === "warning") hasWarnings = true;
   });
   console.log("");
   if (hasErrors) {
-    console.log(chalk2.red("\u274C Some critical issues found. Please fix them before continuing."));
-    results.filter((r) => r.status === "error" && r.fix).forEach((r) => console.log(chalk2.dim(`   ${r.fix}`)));
+    console.log(chalk5.red("\u274C Some critical issues found. Please fix them before continuing."));
+    results.filter((r) => r.status === "error" && r.fix).forEach((r) => console.log(chalk5.dim(`   ${r.fix}`)));
     process.exit(1);
   } else if (hasWarnings) {
-    console.log(chalk2.yellow("\u26A0\uFE0F  Environment is functional but has some warnings."));
-    console.log(chalk2.dim("   Run with --verbose to see fix suggestions."));
+    console.log(chalk5.yellow("\u26A0\uFE0F  Environment is functional but has some warnings."));
+    console.log(chalk5.dim("   Run with --verbose to see fix suggestions."));
   } else {
-    console.log(chalk2.green("\u2705 Environment is healthy and ready for development!"));
+    console.log(chalk5.green("\u2705 Environment is healthy and ready for development!"));
   }
   console.log("");
 });
 
 // src/commands/create.ts
-import { Command as Command3 } from "commander";
-import chalk3 from "chalk";
-import fs3 from "fs";
-import path3 from "path";
+import { Command as Command4 } from "commander";
+import chalk6 from "chalk";
+import fs5 from "fs";
+import path5 from "path";
 var templates = {
   plugin: {
     description: "Create a new ObjectStack plugin",
@@ -223,12 +519,12 @@ var templates = {
         license: "MIT",
         dependencies: {
           "@objectstack/spec": "workspace:*",
-          zod: "^3.22.4"
+          zod: "^4.3.6"
         },
         devDependencies: {
-          "@types/node": "^20.10.0",
-          typescript: "^5.3.0",
-          vitest: "^2.1.8"
+          "@types/node": "^22.0.0",
+          typescript: "^5.8.0",
+          vitest: "^4.0.0"
         }
       }),
       "tsconfig.json": () => ({
@@ -306,17 +602,22 @@ MIT
         dependencies: {
           "@objectstack/spec": "workspace:*",
           "@objectstack/cli": "workspace:*",
-          zod: "^3.22.4"
+          zod: "^4.3.6"
         },
         devDependencies: {
-          "@types/node": "^20.10.0",
+          "@types/node": "^22.0.0",
           tsx: "^4.21.0",
-          typescript: "^5.3.0",
-          vitest: "^2.1.8"
+          typescript: "^5.8.0",
+          vitest: "^4.0.0"
         }
       }),
       "objectstack.config.ts": (name) => `import { defineStack } from '@objectstack/spec';
 
+// Barrel imports \u2014 add more as you create new type folders
+// import * as objects from './src/objects';
+// import * as actions from './src/actions';
+// import * as apps from './src/apps';
+
 export default defineStack({
   manifest: {
     name: '${name}',
@@ -325,12 +626,11 @@ export default defineStack({
   },
   
   objects: [
-    // Define your data objects here
-    // { name: 'my_object', fields: { ... } }
+    // Object.values(objects),  // Uncomment after creating src/objects/index.ts
   ],
   
   apps: [
-    // Define your apps here
+    // Object.values(apps),     // Uncomment after creating src/apps/index.ts
   ],
 });
 `,
@@ -372,81 +672,289 @@ pnpm dev
 function toCamelCase(str) {
   return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
 }
-var createCommand = new Command3("create").description("Create a new package, plugin, or example from template").argument("<type>", "Type of project to create (plugin, example)").argument("[name]", "Name of the project").option("-d, --dir <directory>", "Target directory").action(async (type, name, options) => {
-  console.log(chalk3.bold(`
+var createCommand = new Command4("create").description("Create a new package, plugin, or example from template").argument("<type>", "Type of project to create (plugin, example)").argument("[name]", "Name of the project").option("-d, --dir <directory>", "Target directory").action(async (type, name, options) => {
+  console.log(chalk6.bold(`
 \u{1F4E6} ObjectStack Project Creator`));
-  console.log(chalk3.dim(`-------------------------------`));
+  console.log(chalk6.dim(`-------------------------------`));
   if (!templates[type]) {
-    console.error(chalk3.red(`
+    console.error(chalk6.red(`
 \u274C Unknown type: ${type}`));
-    console.log(chalk3.dim("Available types: plugin, example"));
+    console.log(chalk6.dim("Available types: plugin, example"));
     process.exit(1);
   }
   if (!name) {
-    console.error(chalk3.red("\n\u274C Project name is required"));
-    console.log(chalk3.dim(`Usage: objectstack create ${type} <name>`));
+    console.error(chalk6.red("\n\u274C Project name is required"));
+    console.log(chalk6.dim(`Usage: objectstack create ${type} <name>`));
     process.exit(1);
   }
   const template = templates[type];
   const cwd = process.cwd();
   let targetDir;
   if (options?.dir) {
-    targetDir = path3.resolve(cwd, options.dir);
+    targetDir = path5.resolve(cwd, options.dir);
   } else {
     const baseDir = type === "plugin" ? "packages/plugins" : "examples";
     const projectName = type === "plugin" ? `plugin-${name}` : name;
-    targetDir = path3.join(cwd, baseDir, projectName);
+    targetDir = path5.join(cwd, baseDir, projectName);
   }
-  if (fs3.existsSync(targetDir)) {
-    console.error(chalk3.red(`
+  if (fs5.existsSync(targetDir)) {
+    console.error(chalk6.red(`
 \u274C Directory already exists: ${targetDir}`));
     process.exit(1);
   }
-  console.log(`\u{1F4C1} Creating ${type}: ${chalk3.blue(name)}`);
-  console.log(`\u{1F4C2} Location: ${chalk3.dim(targetDir)}`);
+  console.log(`\u{1F4C1} Creating ${type}: ${chalk6.blue(name)}`);
+  console.log(`\u{1F4C2} Location: ${chalk6.dim(targetDir)}`);
   console.log("");
   try {
-    fs3.mkdirSync(targetDir, { recursive: true });
+    fs5.mkdirSync(targetDir, { recursive: true });
     for (const [filePath, contentFn] of Object.entries(template.files)) {
-      const fullPath = path3.join(targetDir, filePath);
-      const dir = path3.dirname(fullPath);
-      if (!fs3.existsSync(dir)) {
-        fs3.mkdirSync(dir, { recursive: true });
+      const fullPath = path5.join(targetDir, filePath);
+      const dir = path5.dirname(fullPath);
+      if (!fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
       }
       const content = contentFn(name);
       const fileContent = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-      fs3.writeFileSync(fullPath, fileContent);
-      console.log(chalk3.green(`\u2713 Created ${filePath}`));
+      fs5.writeFileSync(fullPath, fileContent);
+      console.log(chalk6.green(`\u2713 Created ${filePath}`));
     }
     console.log("");
-    console.log(chalk3.green("\u2705 Project created successfully!"));
+    console.log(chalk6.green("\u2705 Project created successfully!"));
     console.log("");
-    console.log(chalk3.bold("Next steps:"));
-    console.log(chalk3.dim(`  cd ${path3.relative(cwd, targetDir)}`));
-    console.log(chalk3.dim("  pnpm install"));
-    console.log(chalk3.dim("  pnpm build"));
+    console.log(chalk6.bold("Next steps:"));
+    console.log(chalk6.dim(`  cd ${path5.relative(cwd, targetDir)}`));
+    console.log(chalk6.dim("  pnpm install"));
+    console.log(chalk6.dim("  pnpm build"));
     console.log("");
   } catch (error) {
-    console.error(chalk3.red("\n\u274C Failed to create project:"));
+    console.error(chalk6.red("\n\u274C Failed to create project:"));
     console.error(error.message || error);
-    if (fs3.existsSync(targetDir)) {
-      fs3.rmSync(targetDir, { recursive: true });
+    if (fs5.existsSync(targetDir)) {
+      fs5.rmSync(targetDir, { recursive: true });
     }
     process.exit(1);
   }
 });
 
 // src/commands/serve.ts
-import { Command as Command4 } from "commander";
-import path4 from "path";
-import fs4 from "fs";
+import { Command as Command5 } from "commander";
+import path7 from "path";
+import fs7 from "fs";
+import net2 from "net";
+import chalk7 from "chalk";
+import { bundleRequire as bundleRequire2 } from "bundle-require";
+
+// src/utils/console.ts
+import path6 from "path";
+import fs6 from "fs";
 import net from "net";
-import chalk4 from "chalk";
-import { bundleRequire } from "bundle-require";
+import { spawn as spawn2 } from "child_process";
+var STUDIO_PATH = "/_studio";
+var VITE_PORT_START = 24678;
+function resolveConsolePath() {
+  const cwd = process.cwd();
+  const candidates = [
+    path6.resolve(cwd, "apps/console"),
+    path6.resolve(cwd, "../../apps/console"),
+    path6.resolve(cwd, "../apps/console")
+  ];
+  for (const candidate of candidates) {
+    const pkgPath = path6.join(candidate, "package.json");
+    if (fs6.existsSync(pkgPath)) {
+      try {
+        const pkg2 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+        if (pkg2.name === "@objectstack/console") return candidate;
+      } catch {
+      }
+    }
+  }
+  try {
+    const { createRequire: createRequire2 } = __require("module");
+    const req = createRequire2(import.meta.url);
+    const resolved = req.resolve("@objectstack/console/package.json");
+    return path6.dirname(resolved);
+  } catch {
+    return null;
+  }
+}
+function hasConsoleDist(consolePath) {
+  return fs6.existsSync(path6.join(consolePath, "dist", "index.html"));
+}
+function findAvailablePort(start = VITE_PORT_START) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once("error", () => {
+      findAvailablePort(start + 1).then(resolve, reject);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve(start));
+    });
+    server.listen(start);
+  });
+}
+async function spawnViteDevServer(consolePath, options = {}) {
+  const vitePort = await findAvailablePort(VITE_PORT_START);
+  const viteBinCandidates = [
+    path6.join(consolePath, "node_modules", ".bin", "vite"),
+    path6.join(consolePath, "..", "..", "node_modules", ".bin", "vite")
+  ];
+  let viteBin = null;
+  for (const candidate of viteBinCandidates) {
+    if (fs6.existsSync(candidate)) {
+      viteBin = candidate;
+      break;
+    }
+  }
+  const command = viteBin || "npx";
+  const args = viteBin ? ["--port", String(vitePort), "--strictPort"] : ["vite", "--port", String(vitePort), "--strictPort"];
+  const child = spawn2(command, args, {
+    cwd: consolePath,
+    env: {
+      ...process.env,
+      VITE_BASE: `${STUDIO_PATH}/`,
+      VITE_PORT: String(vitePort),
+      VITE_HMR_PORT: String(vitePort),
+      VITE_RUNTIME_MODE: "server",
+      VITE_SERVER_URL: "",
+      // Same-origin API
+      NODE_ENV: "development"
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stderr = "";
+  child.stderr?.on("data", (data) => {
+    stderr += data.toString();
+  });
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      child.kill();
+      reject(new Error(`Vite dev server timed out after 30 s.
+${stderr}`));
+    }, 3e4);
+    child.stdout?.on("data", (data) => {
+      const output = data.toString();
+      if (output.includes("Local:") || output.includes("ready in")) {
+        clearTimeout(timeout);
+        resolve();
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+    child.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        clearTimeout(timeout);
+        reject(new Error(`Vite exited with code ${code}.
+${stderr}`));
+      }
+    });
+  });
+  return { port: vitePort, process: child };
+}
+function createConsoleProxyPlugin(vitePort) {
+  return {
+    name: "com.objectstack.console-proxy",
+    init: async () => {
+    },
+    start: async (ctx) => {
+      const httpServer = ctx.getService?.("http.server");
+      if (!httpServer?.getRawApp) {
+        ctx.logger?.warn?.("Console proxy: http.server service not found \u2014 skipping");
+        return;
+      }
+      const app = httpServer.getRawApp();
+      app.get(STUDIO_PATH, (c) => c.redirect(`${STUDIO_PATH}/`));
+      app.all(`${STUDIO_PATH}/*`, async (c) => {
+        const targetUrl = `http://localhost:${vitePort}${c.req.path}`;
+        try {
+          const headers = new Headers(c.req.raw.headers);
+          headers.delete("host");
+          const isBodyAllowed = !["GET", "HEAD"].includes(c.req.method);
+          const resp = await fetch(targetUrl, {
+            method: c.req.method,
+            headers,
+            body: isBodyAllowed ? c.req.raw.body : void 0,
+            // @ts-expect-error — duplex required for streaming request body
+            duplex: isBodyAllowed ? "half" : void 0
+          });
+          return new Response(resp.body, {
+            status: resp.status,
+            headers: resp.headers
+          });
+        } catch {
+          return c.text("Console dev server is starting\u2026", 502);
+        }
+      });
+    }
+  };
+}
+function createConsoleStaticPlugin(distPath) {
+  return {
+    name: "com.objectstack.console-static",
+    init: async () => {
+    },
+    start: async (ctx) => {
+      const httpServer = ctx.getService?.("http.server");
+      if (!httpServer?.getRawApp) {
+        ctx.logger?.warn?.("Console static: http.server service not found \u2014 skipping");
+        return;
+      }
+      const app = httpServer.getRawApp();
+      const absoluteDist = path6.resolve(distPath);
+      const indexPath = path6.join(absoluteDist, "index.html");
+      if (!fs6.existsSync(indexPath)) {
+        ctx.logger?.warn?.(`Console static: dist not found at ${absoluteDist}`);
+        return;
+      }
+      app.get(STUDIO_PATH, (c) => c.redirect(`${STUDIO_PATH}/`));
+      app.get(`${STUDIO_PATH}/*`, async (c) => {
+        const reqPath = c.req.path.substring(STUDIO_PATH.length) || "/";
+        const filePath = path6.join(absoluteDist, reqPath);
+        if (!filePath.startsWith(absoluteDist)) {
+          return c.text("Forbidden", 403);
+        }
+        if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
+          const content = fs6.readFileSync(filePath);
+          return new Response(content, {
+            headers: { "content-type": mimeType(filePath) }
+          });
+        }
+        const html = fs6.readFileSync(indexPath);
+        return new Response(html, {
+          headers: { "content-type": "text/html; charset=utf-8" }
+        });
+      });
+    }
+  };
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json"
+};
+function mimeType(filePath) {
+  const ext = path6.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+
+// src/commands/serve.ts
 var getAvailablePort = async (startPort) => {
   const isPortAvailable = (port2) => {
     return new Promise((resolve) => {
-      const server = net.createServer();
+      const server = net2.createServer();
       server.once("error", (err) => {
         resolve(false);
       });
@@ -465,7 +973,7 @@ var getAvailablePort = async (startPort) => {
   }
   return port;
 };
-var serveCommand = new Command4("serve").description("Start ObjectStack server with plugins from configuration").argument("[config]", "Configuration file path", "objectstack.config.ts").option("-p, --port <port>", "Server port", "3000").option("--dev", "Run in development mode (load devPlugins)").option("--no-server", "Skip starting HTTP server plugin").action(async (configPath, options) => {
+var serveCommand = new Command5("serve").description("Start ObjectStack server with plugins from configuration").argument("[config]", "Configuration file path", "objectstack.config.ts").option("-p, --port <port>", "Server port", "3000").option("--dev", "Run in development mode (load devPlugins)").option("--ui", "Enable Console UI at /_studio/").option("--no-server", "Skip starting HTTP server plugin").action(async (configPath, options) => {
   let port = parseInt(options.port);
   try {
     const availablePort = await getAvailablePort(port);
@@ -474,36 +982,59 @@ var serveCommand = new Command4("serve").description("Start ObjectStack server w
     }
   } catch (e) {
   }
-  console.log(chalk4.bold(`
-\u{1F680} ObjectStack Server`));
-  console.log(chalk4.dim(`------------------------`));
-  console.log(`\u{1F4C2} Config: ${chalk4.blue(configPath)}`);
-  if (parseInt(options.port) !== port) {
-    console.log(`\u{1F310} Port: ${chalk4.blue(port)} ${chalk4.yellow(`(requested: ${options.port} in use)`)}`);
-  } else {
-    console.log(`\u{1F310} Port: ${chalk4.blue(port)}`);
-  }
-  console.log("");
-  const absolutePath = path4.resolve(process.cwd(), configPath);
-  if (!fs4.existsSync(absolutePath)) {
-    console.error(chalk4.red(`
-\u274C Configuration file not found: ${absolutePath}`));
+  const isDev = options.dev || process.env.NODE_ENV === "development";
+  const absolutePath = path7.resolve(process.cwd(), configPath);
+  const relativeConfig = path7.relative(process.cwd(), absolutePath);
+  if (!fs7.existsSync(absolutePath)) {
+    printError(`Configuration file not found: ${absolutePath}`);
+    console.log(chalk7.dim("  Hint: Run `objectstack init` to create a new project"));
     process.exit(1);
   }
+  console.log("");
+  console.log(chalk7.dim(`  Loading ${relativeConfig}...`));
+  const loadedPlugins = [];
+  const shortPluginName = (raw) => {
+    if (raw.includes("objectql")) return "ObjectQL";
+    if (raw.includes("driver") && raw.includes("memory")) return "MemoryDriver";
+    if (raw.startsWith("plugin.app.")) return raw.replace("plugin.app.", "").split(".").pop() || raw;
+    if (raw.includes("hono")) return "HonoServer";
+    return raw;
+  };
+  const trackPlugin = (name) => {
+    loadedPlugins.push(shortPluginName(name));
+  };
+  const originalConsoleLog = console.log;
+  const originalConsoleDebug = console.debug;
+  const origStdoutWrite = process.stdout.write.bind(process.stdout);
+  let bootQuiet = false;
+  const restoreOutput = () => {
+    bootQuiet = false;
+    process.stdout.write = origStdoutWrite;
+    console.log = originalConsoleLog;
+    console.debug = originalConsoleDebug;
+  };
+  const portShifted = parseInt(options.port) !== port;
   try {
-    console.log(chalk4.yellow(`\u{1F4E6} Loading configuration...`));
-    const { mod } = await bundleRequire({
+    bootQuiet = true;
+    process.stdout.write = (chunk, ...rest) => {
+      if (bootQuiet) return true;
+      return origStdoutWrite(chunk, ...rest);
+    };
+    console.log = (...args) => {
+      if (!bootQuiet) originalConsoleLog(...args);
+    };
+    console.debug = (...args) => {
+      if (!bootQuiet) originalConsoleDebug(...args);
+    };
+    const { mod } = await bundleRequire2({
       filepath: absolutePath
     });
     const config = mod.default || mod;
     if (!config) {
-      throw new Error(`Default export not found in ${configPath}`);
+      throw new Error(`No default export found in ${configPath}`);
     }
-    console.log(chalk4.green(`\u2713 Configuration loaded`));
     const { Runtime } = await import("@objectstack/runtime");
-    console.log(chalk4.yellow(`\u{1F527} Initializing ObjectStack runtime...`));
-    const isDev = options.dev || process.env.NODE_ENV === "development";
-    const loggerConfig = isDev ? { format: "pretty" } : void 0;
+    const loggerConfig = { level: "silent" };
     const runtime = new Runtime({
       kernel: {
         logger: loggerConfig
@@ -512,48 +1043,40 @@ var serveCommand = new Command4("serve").description("Start ObjectStack server w
     const kernel = runtime.getKernel();
     let plugins = config.plugins || [];
     if (options.dev && config.devPlugins) {
-      console.log(chalk4.blue(`\u{1F4E6} Loading development plugins...`));
       plugins = [...plugins, ...config.devPlugins];
     }
     const hasObjectQL = plugins.some((p) => p.name?.includes("objectql") || p.constructor?.name?.includes("ObjectQL"));
     if (config.objects && !hasObjectQL) {
       try {
-        console.log(chalk4.dim(`  Auto-injecting ObjectQL Engine...`));
         const { ObjectQLPlugin } = await import("@objectstack/objectql");
         await kernel.use(new ObjectQLPlugin());
-        console.log(chalk4.green(`  \u2713 Registered ObjectQL Plugin (auto-detected)`));
+        trackPlugin("ObjectQL");
       } catch (e) {
-        console.warn(chalk4.yellow(`  \u26A0 Could not auto-load ObjectQL: ${e.message}`));
       }
     }
     const hasDriver = plugins.some((p) => p.name?.includes("driver") || p.constructor?.name?.includes("Driver"));
     if (isDev && !hasDriver && config.objects) {
       try {
-        console.log(chalk4.dim(`  Auto-injecting Memory Driver (Dev Mode)...`));
         const { DriverPlugin } = await import("@objectstack/runtime");
         const { InMemoryDriver } = await import("@objectstack/driver-memory");
         await kernel.use(new DriverPlugin(new InMemoryDriver()));
-        console.log(chalk4.green(`  \u2713 Registered Memory Driver (auto-detected)`));
+        trackPlugin("MemoryDriver");
       } catch (e) {
-        console.log(chalk4.dim(`  \u2139 No default driver loaded: ${e.message}`));
       }
     }
     if (config.objects || config.manifest || config.apps) {
       try {
         const { AppPlugin } = await import("@objectstack/runtime");
         await kernel.use(new AppPlugin(config));
-        console.log(chalk4.green(`  \u2713 Registered App Plugin (auto-detected)`));
+        trackPlugin("App");
       } catch (e) {
-        console.warn(chalk4.yellow(`  \u26A0 Could not auto-load AppPlugin: ${e.message}`));
       }
     }
     if (plugins.length > 0) {
-      console.log(chalk4.yellow(`\u{1F4E6} Loading ${plugins.length} plugin(s)...`));
       for (const plugin of plugins) {
         try {
           let pluginToLoad = plugin;
           if (typeof plugin === "string") {
-            console.log(chalk4.dim(`  Trying to resolve plugin: ${plugin}`));
             try {
               const imported = await import(plugin);
               pluginToLoad = imported.default || imported;
@@ -563,9 +1086,9 @@ var serveCommand = new Command4("serve").description("Start ObjectStack server w
           }
           await kernel.use(pluginToLoad);
           const pluginName = plugin.name || plugin.constructor?.name || "unnamed";
-          console.log(chalk4.green(`  \u2713 Registered plugin: ${pluginName}`));
+          trackPlugin(pluginName);
         } catch (e) {
-          console.error(chalk4.red(`  \u2717 Failed to register plugin: ${e.message}`));
+          console.error(chalk7.red(`  \u2717 Failed to load plugin: ${e.message}`));
         }
       }
     }
@@ -574,62 +1097,120 @@ var serveCommand = new Command4("serve").description("Start ObjectStack server w
         const { HonoServerPlugin } = await import("@objectstack/plugin-hono-server");
         const serverPlugin = new HonoServerPlugin({ port });
         await kernel.use(serverPlugin);
-        console.log(chalk4.green(`  \u2713 Registered HTTP server plugin (port: ${port})`));
+        trackPlugin("HonoServer");
       } catch (e) {
-        console.warn(chalk4.yellow(`  \u26A0 HTTP server plugin not available: ${e.message}`));
+        console.warn(chalk7.yellow(`  \u26A0 HTTP server plugin not available: ${e.message}`));
+      }
+    }
+    let viteProcess = null;
+    if (options.ui) {
+      const consolePath = resolveConsolePath();
+      if (!consolePath) {
+        console.warn(chalk7.yellow(`  \u26A0 @objectstack/console not found \u2014 skipping UI`));
+      } else if (isDev) {
+        try {
+          const result = await spawnViteDevServer(consolePath, { serverPort: port });
+          viteProcess = result.process;
+          await kernel.use(createConsoleProxyPlugin(result.port));
+          trackPlugin("ConsoleUI");
+        } catch (e) {
+          console.warn(chalk7.yellow(`  \u26A0 Console UI failed to start: ${e.message}`));
+        }
+      } else {
+        const distPath = path7.join(consolePath, "dist");
+        if (hasConsoleDist(consolePath)) {
+          await kernel.use(createConsoleStaticPlugin(distPath));
+          trackPlugin("ConsoleUI");
+        } else {
+          console.warn(chalk7.yellow(`  \u26A0 Console dist not found \u2014 run "pnpm --filter @objectstack/console build" first`));
+        }
       }
     }
-    console.log(chalk4.yellow(`
-\u{1F680} Starting ObjectStack...`));
     await runtime.start();
-    console.log(chalk4.green(`
-\u2705 ObjectStack server is running!`));
-    console.log(chalk4.dim(`   Press Ctrl+C to stop
-`));
+    await new Promise((r) => setTimeout(r, 100));
+    restoreOutput();
+    printServerReady({
+      port,
+      configFile: relativeConfig,
+      isDev,
+      pluginCount: loadedPlugins.length,
+      pluginNames: loadedPlugins,
+      uiEnabled: !!options.ui,
+      studioPath: STUDIO_PATH
+    });
     process.on("SIGINT", async () => {
-      console.log(chalk4.yellow(`
+      console.warn(chalk7.yellow(`
 
 \u23F9  Stopping server...`));
+      if (viteProcess) {
+        viteProcess.kill();
+        viteProcess = null;
+      }
       await runtime.getKernel().shutdown();
-      console.log(chalk4.green(`\u2705 Server stopped`));
+      console.log(chalk7.green(`\u2705 Server stopped`));
       process.exit(0);
     });
   } catch (error) {
-    console.error(chalk4.red(`
-\u274C Server Error:`));
-    console.error(error.message || error);
-    console.error(error.stack);
+    restoreOutput();
+    console.log("");
+    printError(error.message || String(error));
+    if (process.env.DEBUG) console.error(chalk7.dim(error.stack));
     process.exit(1);
   }
 });
 
+// src/commands/studio.ts
+import { Command as Command6 } from "commander";
+import { spawn as spawn3 } from "child_process";
+var studioCommand = new Command6("studio").description("Launch Console UI with development server").argument("[config]", "Configuration file path", "objectstack.config.ts").option("-p, --port <port>", "Server port", "3000").action(async (configPath, options) => {
+  printHeader("Studio");
+  printKV("Mode", "dev + ui", "\u{1F3A8}");
+  printStep("Delegating to serve --dev --ui \u2026");
+  console.log("");
+  const binPath = process.argv[1];
+  const args = [
+    binPath,
+    "serve",
+    configPath,
+    "--dev",
+    "--ui",
+    "--port",
+    options.port
+  ];
+  const child = spawn3(process.execPath, args, {
+    stdio: "inherit",
+    env: { ...process.env, NODE_ENV: "development" }
+  });
+  child.on("exit", (code) => process.exit(code ?? 0));
+});
+
 // src/commands/test.ts
-import { Command as Command5 } from "commander";
-import chalk5 from "chalk";
-import path5 from "path";
-import fs5 from "fs";
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
+import path8 from "path";
+import fs8 from "fs";
 import { QA as CoreQA } from "@objectstack/core";
-var testCommand = new Command5("test:run").description("Run Quality Protocol test scenarios").argument("[files]", 'Glob pattern for test files (e.g. "qa/*.test.json")', "qa/*.test.json").option("--url <url>", "Target base URL", "http://localhost:3000").option("--token <token>", "Authentication token").action(async (filesPattern, options) => {
-  console.log(chalk5.bold(`
+var testCommand = new Command7("test").description("Run Quality Protocol test scenarios against a running server").argument("[files]", 'Glob pattern for test files (e.g. "qa/*.test.json")', "qa/*.test.json").option("--url <url>", "Target base URL", "http://localhost:3000").option("--token <token>", "Authentication token").action(async (filesPattern, options) => {
+  console.log(chalk8.bold(`
 \u{1F9EA} ObjectStack Quality Protocol Runner`));
-  console.log(chalk5.dim(`-------------------------------------`));
-  console.log(`Target: ${chalk5.blue(options.url)}`);
+  console.log(chalk8.dim(`-------------------------------------`));
+  console.log(`Target: ${chalk8.blue(options.url)}`);
   const adapter = new CoreQA.HttpTestAdapter(options.url, options.token);
   const runner = new CoreQA.TestRunner(adapter);
   const cwd = process.cwd();
   const testFiles = [];
-  if (fs5.existsSync(filesPattern)) {
+  if (fs8.existsSync(filesPattern)) {
     testFiles.push(filesPattern);
   } else {
-    const dir = path5.dirname(filesPattern);
-    const ext = path5.extname(filesPattern);
-    if (fs5.existsSync(dir)) {
-      const files = fs5.readdirSync(dir).filter((f) => f.endsWith(ext) || f.endsWith(".json"));
-      files.forEach((f) => testFiles.push(path5.join(dir, f)));
+    const dir = path8.dirname(filesPattern);
+    const ext = path8.extname(filesPattern);
+    if (fs8.existsSync(dir)) {
+      const files = fs8.readdirSync(dir).filter((f) => f.endsWith(ext) || f.endsWith(".json"));
+      files.forEach((f) => testFiles.push(path8.join(dir, f)));
     }
   }
   if (testFiles.length === 0) {
-    console.warn(chalk5.yellow(`No test files found matching: ${filesPattern}`));
+    console.warn(chalk8.yellow(`No test files found matching: ${filesPattern}`));
     return;
   }
   console.log(`Found ${testFiles.length} test suites.`);
@@ -637,19 +1218,19 @@ var testCommand = new Command5("test:run").description("Run Quality Protocol tes
   let totalFailed = 0;
   for (const file of testFiles) {
     console.log(`
-\u{1F4C4} Running suite: ${chalk5.bold(path5.basename(file))}`);
+\u{1F4C4} Running suite: ${chalk8.bold(path8.basename(file))}`);
     try {
-      const content = fs5.readFileSync(file, "utf-8");
+      const content = fs8.readFileSync(file, "utf-8");
       const suite = JSON.parse(content);
       const results = await runner.runSuite(suite);
       for (const result of results) {
         const icon = result.passed ? "\u2705" : "\u274C";
         console.log(`  ${icon} Scenario: ${result.scenarioId} (${result.duration}ms)`);
         if (!result.passed) {
-          console.error(chalk5.red(`     Error: ${result.error}`));
+          console.error(chalk8.red(`     Error: ${result.error}`));
           result.steps.forEach((step) => {
             if (!step.passed) {
-              console.error(chalk5.red(`     Step Failed: ${step.stepName}`));
+              console.error(chalk8.red(`     Step Failed: ${step.stepName}`));
               if (step.output) console.error(`     Output:`, step.output);
               if (step.error) console.error(`     Error:`, step.error);
             }
@@ -660,30 +1241,759 @@ var testCommand = new Command5("test:run").description("Run Quality Protocol tes
         }
       }
     } catch (e) {
-      console.error(chalk5.red(`Failed to load or run suite ${file}: ${e}`));
+      console.error(chalk8.red(`Failed to load or run suite ${file}: ${e}`));
       totalFailed++;
     }
   }
-  console.log(chalk5.dim(`
+  console.log(chalk8.dim(`
 -------------------------------------`));
   if (totalFailed > 0) {
-    console.log(chalk5.red(`FAILED: ${totalFailed} scenarios failed. ${totalPassed} passed.`));
+    console.log(chalk8.red(`FAILED: ${totalFailed} scenarios failed. ${totalPassed} passed.`));
     process.exit(1);
   } else {
-    console.log(chalk5.green(`SUCCESS: All ${totalPassed} scenarios passed.`));
+    console.log(chalk8.green(`SUCCESS: All ${totalPassed} scenarios passed.`));
     process.exit(0);
   }
 });
 
+// src/commands/validate.ts
+import { Command as Command8 } from "commander";
+import chalk9 from "chalk";
+import { ObjectStackDefinitionSchema as ObjectStackDefinitionSchema2 } from "@objectstack/spec";
+var validateCommand = new Command8("validate").description("Validate ObjectStack configuration against the protocol schema").argument("[config]", "Configuration file path").option("--strict", "Treat warnings as errors").option("--json", "Output results as JSON").action(async (configPath, options) => {
+  const timer = createTimer();
+  if (!options.json) {
+    printHeader("Validate");
+  }
+  try {
+    if (!options.json) printStep("Loading configuration...");
+    const { config, absolutePath, duration } = await loadConfig(configPath);
+    if (!options.json) {
+      printKV("Config", absolutePath);
+      printKV("Load time", `${duration}ms`);
+    }
+    if (!options.json) printStep("Validating against ObjectStack Protocol...");
+    const result = ObjectStackDefinitionSchema2.safeParse(config);
+    if (!result.success) {
+      if (options.json) {
+        console.log(JSON.stringify({
+          valid: false,
+          errors: result.error.issues,
+          duration: timer.elapsed()
+        }, null, 2));
+        process.exit(1);
+      }
+      console.log("");
+      printError("Validation failed");
+      formatZodErrors(result.error);
+      process.exit(1);
+    }
+    const stats = collectMetadataStats(config);
+    if (options.json) {
+      console.log(JSON.stringify({
+        valid: true,
+        manifest: config.manifest,
+        stats,
+        duration: timer.elapsed()
+      }, null, 2));
+      return;
+    }
+    const warnings = [];
+    if (stats.objects === 0) {
+      warnings.push("No objects defined \u2014 this stack has no data model");
+    }
+    if (stats.apps === 0 && stats.plugins === 0) {
+      warnings.push("No apps or plugins defined \u2014 this stack may not do much");
+    }
+    if (!config.manifest?.id) {
+      warnings.push("Missing manifest.id \u2014 required for deployment");
+    }
+    if (!config.manifest?.namespace) {
+      warnings.push("Missing manifest.namespace \u2014 required for multi-app hosting");
+    }
+    console.log("");
+    printSuccess(`Validation passed ${chalk9.dim(`(${timer.display()})`)}`);
+    console.log("");
+    if (config.manifest) {
+      console.log(`  ${chalk9.bold(config.manifest.name || config.manifest.id || "Unnamed")} ${chalk9.dim(`v${config.manifest.version || "0.0.0"}`)}`);
+      if (config.manifest.description) {
+        console.log(chalk9.dim(`  ${config.manifest.description}`));
+      }
+      console.log("");
+    }
+    printMetadataStats(stats);
+    if (warnings.length > 0) {
+      console.log("");
+      for (const w of warnings) {
+        console.log(chalk9.yellow(`  \u26A0 ${w}`));
+      }
+      if (options.strict) {
+        console.log("");
+        printError("Strict mode: warnings treated as errors");
+        process.exit(1);
+      }
+    }
+    console.log("");
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        valid: false,
+        error: error.message,
+        duration: timer.elapsed()
+      }, null, 2));
+      process.exit(1);
+    }
+    console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command9 } from "commander";
+import chalk10 from "chalk";
+import fs9 from "fs";
+import path9 from "path";
+var TEMPLATES = {
+  app: {
+    description: "Full application with objects, views, and actions",
+    dependencies: {
+      "@objectstack/spec": "workspace:*",
+      "@objectstack/runtime": "workspace:^",
+      "@objectstack/objectql": "workspace:^",
+      "@objectstack/driver-memory": "workspace:^"
+    },
+    devDependencies: {
+      "@objectstack/cli": "workspace:*",
+      "typescript": "^5.3.0"
+    },
+    scripts: {
+      dev: "objectstack dev",
+      start: "objectstack serve",
+      build: "objectstack compile",
+      validate: "objectstack validate",
+      typecheck: "tsc --noEmit"
+    },
+    configContent: (name) => `import { defineStack } from '@objectstack/spec';
+import * as objects from './src/objects';
+
+export default defineStack({
+  manifest: {
+    id: 'com.example.${name}',
+    namespace: '${name}',
+    version: '0.1.0',
+    type: 'app',
+    name: '${toTitleCase(name)}',
+    description: '${toTitleCase(name)} application built with ObjectStack',
+  },
+
+  objects: Object.values(objects),
+});
+`,
+    srcFiles: {
+      "src/objects/index.ts": (name) => `export { default as ${toCamelCase2(name)} } from './${name}';
+`,
+      "src/objects/__name__.ts": (name) => `import { Data } from '@objectstack/spec';
+
+const ${toCamelCase2(name)}: Data.Object = {
+  name: '${name}',
+  label: '${toTitleCase(name)}',
+  ownership: 'own',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      required: true,
+    },
+    description: {
+      type: 'textarea',
+      label: 'Description',
+    },
+    status: {
+      type: 'select',
+      label: 'Status',
+      options: [
+        { label: 'Draft', value: 'draft' },
+        { label: 'Active', value: 'active' },
+        { label: 'Archived', value: 'archived' },
+      ],
+      defaultValue: 'draft',
+    },
+  },
+};
+
+export default ${toCamelCase2(name)};
+`
+    }
+  },
+  plugin: {
+    description: "Reusable plugin with objects and extensions",
+    dependencies: {
+      "@objectstack/spec": "workspace:*"
+    },
+    devDependencies: {
+      "typescript": "^5.3.0",
+      "vitest": "^4.0.18"
+    },
+    scripts: {
+      build: "objectstack compile",
+      validate: "objectstack validate",
+      test: "vitest run",
+      typecheck: "tsc --noEmit"
+    },
+    configContent: (name) => `import { defineStack } from '@objectstack/spec';
+import * as objects from './src/objects';
+
+export default defineStack({
+  manifest: {
+    id: 'com.objectstack.plugin-${name}',
+    namespace: 'plugin_${name}',
+    version: '0.1.0',
+    type: 'plugin',
+    name: '${toTitleCase(name)} Plugin',
+    description: 'ObjectStack Plugin: ${toTitleCase(name)}',
+  },
+
+  objects: Object.values(objects),
+});
+`,
+    srcFiles: {
+      "src/objects/index.ts": (name) => `export { default as ${toCamelCase2(name)} } from './${name}';
+`,
+      "src/objects/__name__.ts": (name) => `import { Data } from '@objectstack/spec';
+
+const ${toCamelCase2(name)}: Data.Object = {
+  name: '${name}',
+  label: '${toTitleCase(name)}',
+  ownership: 'own',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      required: true,
+    },
+  },
+};
+
+export default ${toCamelCase2(name)};
+`
+    }
+  },
+  empty: {
+    description: "Minimal project with just a config file",
+    dependencies: {
+      "@objectstack/spec": "workspace:*"
+    },
+    devDependencies: {
+      "@objectstack/cli": "workspace:*",
+      "typescript": "^5.3.0"
+    },
+    scripts: {
+      build: "objectstack compile",
+      validate: "objectstack validate",
+      typecheck: "tsc --noEmit"
+    },
+    configContent: (name) => `import { defineStack } from '@objectstack/spec';
+
+export default defineStack({
+  manifest: {
+    id: 'com.example.${name}',
+    namespace: '${name}',
+    version: '0.1.0',
+    type: 'app',
+    name: '${toTitleCase(name)}',
+    description: '',
+  },
+});
+`,
+    srcFiles: {}
+  }
+};
+function toCamelCase2(str) {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toTitleCase(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+var initCommand = new Command9("init").description("Initialize a new ObjectStack project in the current directory").argument("[name]", "Project name (defaults to directory name)").option("-t, --template <template>", "Template: app, plugin, empty", "app").option("--no-install", "Skip dependency installation").action(async (name, options) => {
+  printHeader("Init");
+  const cwd = process.cwd();
+  const projectName = name || path9.basename(cwd);
+  const template = TEMPLATES[options.template];
+  if (!template) {
+    printError(`Unknown template: ${options.template}`);
+    console.log(chalk10.dim(`  Available: ${Object.keys(TEMPLATES).join(", ")}`));
+    process.exit(1);
+  }
+  if (fs9.existsSync(path9.join(cwd, "objectstack.config.ts"))) {
+    printError("objectstack.config.ts already exists in this directory");
+    console.log(chalk10.dim("  Use `objectstack generate` to add metadata to an existing project"));
+    process.exit(1);
+  }
+  printKV("Project", projectName);
+  printKV("Template", `${options.template} \u2014 ${template.description}`);
+  printKV("Directory", cwd);
+  console.log("");
+  const createdFiles = [];
+  try {
+    const pkgPath = path9.join(cwd, "package.json");
+    if (!fs9.existsSync(pkgPath)) {
+      const pkg2 = {
+        name: projectName,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: template.scripts,
+        dependencies: template.dependencies,
+        devDependencies: template.devDependencies
+      };
+      fs9.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n");
+      createdFiles.push("package.json");
+    } else {
+      printInfo("package.json already exists, skipping");
+    }
+    const configContent = template.configContent(projectName);
+    fs9.writeFileSync(path9.join(cwd, "objectstack.config.ts"), configContent);
+    createdFiles.push("objectstack.config.ts");
+    const tsconfigPath = path9.join(cwd, "tsconfig.json");
+    if (!fs9.existsSync(tsconfigPath)) {
+      const tsconfig = {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          outDir: "dist",
+          rootDir: ".",
+          declaration: true
+        },
+        include: ["*.ts", "src/**/*"],
+        exclude: ["dist", "node_modules"]
+      };
+      fs9.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+      createdFiles.push("tsconfig.json");
+    }
+    for (const [filePath, contentFn] of Object.entries(template.srcFiles)) {
+      const resolvedPath = filePath.replace("__name__", projectName);
+      const fullPath = path9.join(cwd, resolvedPath);
+      const dir = path9.dirname(fullPath);
+      if (!fs9.existsSync(dir)) {
+        fs9.mkdirSync(dir, { recursive: true });
+      }
+      fs9.writeFileSync(fullPath, contentFn(projectName));
+      createdFiles.push(resolvedPath);
+    }
+    const gitignorePath = path9.join(cwd, ".gitignore");
+    if (!fs9.existsSync(gitignorePath)) {
+      fs9.writeFileSync(gitignorePath, `node_modules/
+dist/
+*.tsbuildinfo
+`);
+      createdFiles.push(".gitignore");
+    }
+    console.log(chalk10.bold("  Created files:"));
+    for (const f of createdFiles) {
+      console.log(chalk10.green(`    + ${f}`));
+    }
+    console.log("");
+    if (options.install !== false) {
+      printStep("Installing dependencies...");
+      const { execSync: execSync3 } = await import("child_process");
+      try {
+        execSync3("pnpm install", { stdio: "inherit", cwd });
+      } catch {
+        printWarning2("Dependency installation failed. Run `pnpm install` manually.");
+      }
+    }
+    printSuccess("Project initialized!");
+    console.log("");
+    console.log(chalk10.bold("  Next steps:"));
+    console.log(chalk10.dim("    objectstack validate   # Check configuration"));
+    console.log(chalk10.dim("    objectstack dev        # Start development server"));
+    console.log(chalk10.dim("    objectstack generate   # Add objects, views, etc."));
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+function printWarning2(msg) {
+  console.log(chalk10.yellow(`  \u26A0 ${msg}`));
+}
+
+// src/commands/info.ts
+import { Command as Command10 } from "commander";
+import chalk11 from "chalk";
+var infoCommand = new Command10("info").description("Display metadata summary of an ObjectStack configuration").argument("[config]", "Configuration file path").option("--json", "Output as JSON").action(async (configPath, options) => {
+  const timer = createTimer();
+  if (!options.json) {
+    printHeader("Info");
+  }
+  try {
+    const { config, absolutePath, duration } = await loadConfig(configPath);
+    const stats = collectMetadataStats(config);
+    if (options.json) {
+      console.log(JSON.stringify({
+        config: absolutePath,
+        manifest: config.manifest || null,
+        stats,
+        objects: (config.objects || []).map((o) => ({
+          name: o.name,
+          label: o.label,
+          fields: o.fields ? Object.keys(o.fields).length : 0
+        })),
+        loadTime: duration
+      }, null, 2));
+      return;
+    }
+    if (config.manifest) {
+      const m = config.manifest;
+      console.log("");
+      console.log(`  ${chalk11.bold(m.name || m.id || "Unnamed")} ${chalk11.dim(`v${m.version || "0.0.0"}`)}`);
+      if (m.id) console.log(chalk11.dim(`  ${m.id}`));
+      if (m.description) console.log(chalk11.dim(`  ${m.description}`));
+      if (m.namespace) printKV("  Namespace", m.namespace);
+      if (m.type) printKV("  Type", m.type);
+    }
+    console.log("");
+    printMetadataStats(stats);
+    if (config.objects && config.objects.length > 0) {
+      console.log("");
+      console.log(chalk11.bold("  Objects:"));
+      for (const obj of config.objects) {
+        const fieldCount = obj.fields ? Object.keys(obj.fields).length : 0;
+        const ownership = obj.ownership || "own";
+        console.log(
+          `    ${chalk11.cyan(obj.name || "?")}` + chalk11.dim(` (${fieldCount} fields, ${ownership})`) + (obj.label ? chalk11.dim(` \u2014 ${obj.label}`) : "")
+        );
+      }
+    }
+    if (config.agents && config.agents.length > 0) {
+      console.log("");
+      console.log(chalk11.bold("  Agents:"));
+      for (const agent of config.agents) {
+        console.log(
+          `    ${chalk11.magenta(agent.name || "?")}` + (agent.role ? chalk11.dim(` \u2014 ${agent.role}`) : "")
+        );
+      }
+    }
+    if (config.apps && config.apps.length > 0) {
+      console.log("");
+      console.log(chalk11.bold("  Apps:"));
+      for (const app of config.apps) {
+        console.log(
+          `    ${chalk11.green(app.name || "?")}` + (app.label ? chalk11.dim(` \u2014 ${app.label}`) : "")
+        );
+      }
+    }
+    console.log("");
+    console.log(chalk11.dim(`  Loaded in ${duration}ms`));
+    console.log("");
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: error.message }));
+      process.exit(1);
+    }
+    console.log("");
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
+// src/commands/generate.ts
+import { Command as Command11 } from "commander";
+import chalk12 from "chalk";
+import fs10 from "fs";
+import path10 from "path";
+var GENERATORS = {
+  object: {
+    description: "Business data object",
+    defaultDir: "src/objects",
+    generate: (name) => `import { Data } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Object
+ */
+const ${toCamelCase3(name)}: Data.Object = {
+  name: '${toSnakeCase(name)}',
+  label: '${toTitleCase2(name)}',
+  pluralLabel: '${toTitleCase2(name)}s',
+  ownership: 'own',
+  fields: {
+    name: {
+      type: 'text',
+      label: 'Name',
+      required: true,
+      maxLength: 255,
+    },
+    description: {
+      type: 'textarea',
+      label: 'Description',
+    },
+  },
+};
+
+export default ${toCamelCase3(name)};
+`
+  },
+  view: {
+    description: "List or form view",
+    defaultDir: "src/views",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} List View
+ */
+const ${toCamelCase3(name)}ListView: UI.View = {
+  name: '${toSnakeCase(name)}_list',
+  label: '${toTitleCase2(name)} List',
+  type: 'list',
+  objectName: '${toSnakeCase(name)}',
+  list: {
+    type: 'grid',
+    columns: [
+      { field: 'name', width: 200 },
+    ],
+    defaultSort: { field: 'name', direction: 'asc' },
+    pageSize: 25,
+  },
+};
+
+export default ${toCamelCase3(name)}ListView;
+`
+  },
+  action: {
+    description: "Button or batch action",
+    defaultDir: "src/actions",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Action
+ */
+const ${toCamelCase3(name)}Action: UI.Action = {
+  name: '${toSnakeCase(name)}',
+  label: '${toTitleCase2(name)}',
+  type: 'custom',
+  objectName: '${toSnakeCase(name)}',
+  handler: {
+    type: 'flow',
+    target: '${toSnakeCase(name)}_flow',
+  },
+};
+
+export default ${toCamelCase3(name)}Action;
+`
+  },
+  flow: {
+    description: "Automation flow",
+    defaultDir: "src/flows",
+    generate: (name) => `import { Automation } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Flow
+ */
+const ${toCamelCase3(name)}Flow: Automation.Flow = {
+  name: '${toSnakeCase(name)}_flow',
+  label: '${toTitleCase2(name)} Flow',
+  type: 'autolaunched',
+  status: 'draft',
+  trigger: {
+    type: 'record_change',
+    object: '${toSnakeCase(name)}',
+    events: ['after_insert', 'after_update'],
+  },
+  nodes: [
+    {
+      id: 'start',
+      type: 'start',
+      name: 'Start',
+      next: 'end',
+    },
+  ],
+};
+
+export default ${toCamelCase3(name)}Flow;
+`
+  },
+  agent: {
+    description: "AI agent",
+    defaultDir: "src/agents",
+    generate: (name) => `import { AI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Agent
+ */
+const ${toCamelCase3(name)}Agent: AI.Agent = {
+  name: '${toSnakeCase(name)}_agent',
+  label: '${toTitleCase2(name)} Agent',
+  role: '${toTitleCase2(name)} assistant',
+  instructions: 'You are a helpful ${toTitleCase2(name).toLowerCase()} assistant.',
+  model: {
+    provider: 'openai',
+    model: 'gpt-4o',
+  },
+  tools: [],
+};
+
+export default ${toCamelCase3(name)}Agent;
+`
+  },
+  dashboard: {
+    description: "Analytics dashboard",
+    defaultDir: "src/dashboards",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} Dashboard
+ */
+const ${toCamelCase3(name)}Dashboard: UI.Dashboard = {
+  name: '${toSnakeCase(name)}_dashboard',
+  label: '${toTitleCase2(name)} Dashboard',
+  widgets: [],
+};
+
+export default ${toCamelCase3(name)}Dashboard;
+`
+  },
+  app: {
+    description: "Application navigation",
+    defaultDir: "src/apps",
+    generate: (name) => `import { UI } from '@objectstack/spec';
+
+/**
+ * ${toTitleCase2(name)} App
+ */
+const ${toCamelCase3(name)}App: UI.App = {
+  name: '${toSnakeCase(name)}_app',
+  label: '${toTitleCase2(name)}',
+  navigation: {
+    type: 'sidebar',
+    items: [],
+  },
+};
+
+export default ${toCamelCase3(name)}App;
+`
+  }
+};
+function toCamelCase3(str) {
+  return str.replace(/[-_]([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toTitleCase2(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function toSnakeCase(str) {
+  return str.replace(/[-]/g, "_").replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`).replace(/^_/, "");
+}
+var generateCommand = new Command11("generate").alias("g").description("Generate metadata files (object, view, action, flow, agent, dashboard, app)").argument("<type>", "Metadata type to generate").argument("<name>", "Name for the metadata (use kebab-case)").option("-d, --dir <directory>", "Target directory (overrides default)").option("--dry-run", "Show what would be created without writing files").action(async (type, name, options) => {
+  printHeader("Generate");
+  const generator = GENERATORS[type];
+  if (!generator) {
+    printError(`Unknown type: ${type}`);
+    console.log("");
+    console.log(chalk12.bold("  Available types:"));
+    for (const [key, gen] of Object.entries(GENERATORS)) {
+      console.log(`    ${chalk12.cyan(key.padEnd(12))} ${chalk12.dim(gen.description)}`);
+    }
+    console.log("");
+    console.log(chalk12.dim("  Usage: objectstack generate <type> <name>"));
+    console.log(chalk12.dim("  Example: objectstack generate object project"));
+    console.log(chalk12.dim("  Alias: os g object project"));
+    process.exit(1);
+  }
+  const dir = options.dir || generator.defaultDir;
+  const fileName = `${toSnakeCase(name)}.ts`;
+  const filePath = path10.join(process.cwd(), dir, fileName);
+  console.log(`  ${chalk12.dim("Type:")}  ${chalk12.cyan(type)} \u2014 ${generator.description}`);
+  console.log(`  ${chalk12.dim("Name:")}  ${chalk12.white(name)}`);
+  console.log(`  ${chalk12.dim("File:")}  ${chalk12.white(path10.join(dir, fileName))}`);
+  console.log("");
+  if (options.dryRun) {
+    printInfo("Dry run \u2014 no files written");
+    console.log("");
+    console.log(chalk12.dim("  Content:"));
+    console.log(chalk12.dim("  " + "-".repeat(38)));
+    const content = generator.generate(name);
+    for (const line of content.split("\n")) {
+      console.log(chalk12.dim(`  ${line}`));
+    }
+    console.log("");
+    return;
+  }
+  if (fs10.existsSync(filePath)) {
+    printError(`File already exists: ${filePath}`);
+    process.exit(1);
+  }
+  try {
+    const fullDir = path10.dirname(filePath);
+    if (!fs10.existsSync(fullDir)) {
+      fs10.mkdirSync(fullDir, { recursive: true });
+    }
+    const content = generator.generate(name);
+    fs10.writeFileSync(filePath, content);
+    printSuccess(`Created ${path10.join(dir, fileName)}`);
+    const indexPath = path10.join(process.cwd(), dir, "index.ts");
+    if (fs10.existsSync(indexPath)) {
+      const indexContent = fs10.readFileSync(indexPath, "utf-8");
+      const exportLine = `export { default as ${toCamelCase3(name)} } from './${toSnakeCase(name)}';`;
+      if (!indexContent.includes(toCamelCase3(name))) {
+        fs10.appendFileSync(indexPath, exportLine + "\n");
+        printSuccess(`Updated ${dir}/index.ts with export`);
+      }
+    } else {
+      const exportLine = `export { default as ${toCamelCase3(name)} } from './${toSnakeCase(name)}';
+`;
+      fs10.writeFileSync(indexPath, exportLine);
+      printSuccess(`Created ${dir}/index.ts`);
+    }
+    console.log("");
+    console.log(chalk12.dim(`  Tip: Run \`objectstack validate\` to check your config`));
+    console.log("");
+  } catch (error) {
+    printError(error.message || String(error));
+    process.exit(1);
+  }
+});
+
 // src/bin.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
-var program = new Command6();
-program.name("objectstack").description("CLI for ObjectStack Protocol - Development Tools for Microkernel Architecture").version(pkg.version);
-program.addCommand(compileCommand);
-program.addCommand(serveCommand);
+process.on("unhandledRejection", (err) => {
+  console.error(chalk13.red(`
+  \u2717 Unhandled error: ${err?.message || err}`));
+  if (err?.stack && process.env.DEBUG) {
+    console.error(chalk13.dim(err.stack));
+  }
+  process.exit(1);
+});
+var program = new Command12();
+program.name("objectstack").description("ObjectStack CLI \u2014 Build metadata-driven apps with the ObjectStack Protocol").version(pkg.version, "-v, --version").configureHelp({
+  sortSubcommands: false
+}).addHelpText("before", `
+${chalk13.bold.cyan("\u25C6 ObjectStack CLI")} ${chalk13.dim(`v${pkg.version}`)}
+`).addHelpText("after", `
+${chalk13.bold("Workflow:")}
+  ${chalk13.dim("$")} os init                      ${chalk13.dim("# Create a new project")}
+  ${chalk13.dim("$")} os generate object task       ${chalk13.dim("# Add metadata")}
+  ${chalk13.dim("$")} os validate                   ${chalk13.dim("# Check configuration")}
+  ${chalk13.dim("$")} os dev                        ${chalk13.dim("# Start dev server")}
+  ${chalk13.dim("$")} os studio                     ${chalk13.dim("# Dev server + Console UI")}
+  ${chalk13.dim("$")} os compile                    ${chalk13.dim("# Build for production")}
+
+${chalk13.dim("Aliases: objectstack | os")}
+${chalk13.dim("Docs: https://objectstack.dev")}
+`);
+program.addCommand(initCommand);
 program.addCommand(devCommand);
-program.addCommand(doctorCommand);
+program.addCommand(serveCommand);
+program.addCommand(studioCommand);
+program.addCommand(compileCommand);
+program.addCommand(validateCommand);
+program.addCommand(infoCommand);
+program.addCommand(generateCommand);
 program.addCommand(createCommand);
 program.addCommand(testCommand);
+program.addCommand(doctorCommand);
 program.parse(process.argv);