nits

packages/cli/src/cli.ts

···
         });
       },
       async (argv) => {
-        await initCommand(argv.setup);
+        // Extract any unknown flags to pass through to package manager
+        const flags: string[] = [];
+        const knownFlags = new Set(["setup", "_", "$0"]);
+
+        for (const [key, value] of Object.entries(argv)) {
+          if (!knownFlags.has(key)) {
+            // Single letter = short flag, multiple letters = long flag
+            const prefix = key.length === 1 ? "-" : "--";
+            if (typeof value === "boolean" && value) {
+              flags.push(`${prefix}${key}`);
+            } else if (value !== false && value !== undefined) {
+              flags.push(`${prefix}${key}`, String(value));
+            }
+          }
+        }
+
+        await initCommand(argv.setup, flags);
       }
     )
     .command(

packages/cli/src/commands/init.ts

···
 import { createInterface } from "readline";
 import pc from "picocolors";
 
-// Gradient colors matching website (approximated with ANSI 256 colors)
-// Darker variant for better readability on white terminals
 function gradientText(text: string): string {
-  // Approximating: #4a9eff -> #7a8ef7 -> #ff85c1 -> #9b7ef7
-  // Using darker ANSI 256 color codes for a blue->purple->pink gradient
   const colors = [
-    '\x1b[38;5;33m',  // darker blue
-    '\x1b[38;5;69m',  // blue-purple
-    '\x1b[38;5;99m',  // purple
-    '\x1b[38;5;133m', // purple-pink
-    '\x1b[38;5;170m', // pink
-    '\x1b[38;5;170m', // pink
-    '\x1b[38;5;133m', // purple-pink
+    '\x1b[38;5;33m',
+    '\x1b[38;5;69m',
+    '\x1b[38;5;99m',
+    '\x1b[38;5;133m',
+    '\x1b[38;5;170m',
+    '\x1b[38;5;170m',
+    '\x1b[38;5;133m',
   ];
   const reset = '\x1b[0m';
 
···
   });
 }
 
-/**
- * Initialize command - installs packages and hands off to local version
- * This is what gets called by npx
- */
-export async function initCommand(isSetup: boolean = false): Promise<void> {
-  const cwd = process.cwd();
+export async function initCommand(isSetup: boolean = false, flags: string[] = []): Promise<void> {
+  const originalCwd = process.cwd();
+
+  // Find nearest package.json upward
+  let projectRoot = originalCwd;
+  let dir = originalCwd;
+  while (dir !== resolve(dir, "..")) {
+    try {
+      await access(resolve(dir, "package.json"));
+      projectRoot = dir;
+      break;
+    } catch {
+      dir = resolve(dir, "..");
+    }
+  }
 
-  // If this is the second pass (after handoff), run setup
   if (isSetup) {
     return initSetup();
   }
 
   console.log(`Adding ${gradientText("typelex")}...\n`);
 
-  // Detect package manager: walk up from cwd
+  // Detect package manager
   let packageManager = "npm";
-  let dir = cwd;
+  dir = projectRoot;
   while (dir !== resolve(dir, "..") && packageManager === "npm") {
     try {
       await access(resolve(dir, "pnpm-lock.yaml"));
···
     dir = resolve(dir, "..");
   }
 
-  // Install dependencies (always use latest)
+  // Install dependencies
   await new Promise<void>((resolvePromise, reject) => {
     const args = packageManager === "npm"
       ? ["install", "--save-dev", "@typelex/cli@latest", "@typelex/emitter@latest"]
       : ["add", "-D", "@typelex/cli@latest", "@typelex/emitter@latest"];
 
+    // Add any additional flags
+    args.push(...flags);
+
     const install = spawn(packageManager, args, {
-      cwd,
+      cwd: projectRoot,
       stdio: "inherit",
     });
 
···
     });
   });
 
-  // Hand off to locally installed version
-  // Find where node_modules actually is (could be at workspace root with pnpm)
-  let nodeModulesDir = resolve(cwd, "node_modules");
-  let searchDir = cwd;
-
-  // Search upward for node_modules with typelex installed
+  // Find node_modules
+  let nodeModulesDir = resolve(projectRoot, "node_modules");
+  let searchDir = projectRoot;
   while (searchDir !== resolve(searchDir, "..")) {
     try {
       const candidatePath = resolve(searchDir, "node_modules/.bin/typelex");
···
       nodeModulesDir = resolve(searchDir, "node_modules");
       break;
     } catch {
-      // Not found, try parent
+      searchDir = resolve(searchDir, "..");
     }
-    searchDir = resolve(searchDir, "..");
   }
 
   return new Promise((resolvePromise, reject) => {
     const localCli = resolve(nodeModulesDir, ".bin/typelex");
     const setup = spawn(localCli, ["init", "--setup"], {
-      cwd,
+      cwd: projectRoot,
       stdio: "inherit",
     });
 
···
   });
 }
 
-/**
- * Setup function - called after packages are installed
- * This runs from the locally installed version
- */
 export async function initSetup(): Promise<void> {
   const cwd = process.cwd();
   const typelexDir = resolve(cwd, "typelex");