@c15t/cli 2.0.0-rc.6 → 2.0.0

package/dist/145.mjs

@@ -1,17 +1,18 @@
 import "dotenv/config";
 import open_0 from "open";
 import picocolors from "picocolors";
-import promises, { readdir, writeFile } from "node:fs/promises";
-import node_path, { extname, join as external_node_path_join } from "node:path";
+import promises, { readFile, readdir, writeFile } from "node:fs/promises";
+import node_path, { dirname, extname, join as external_node_path_join, relative, resolve as external_node_path_resolve } from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
-import { existsSync as external_node_fs_existsSync } from "node:fs";
+import node_fs, { existsSync as external_node_fs_existsSync } from "node:fs";
 import { assign as external_xstate_assign, createActor, fromPromise, setup } from "xstate";
 import node_crypto from "node:crypto";
 import node_os from "node:os";
-import { PostHog } from "posthog-node";
+import { createLogger, initLogger } from "evlog";
+import { createDrainPipeline } from "evlog/pipeline";
 import { spawn as external_node_child_process_spawn } from "node:child_process";
 import { once } from "node:events";
-import { createLogger } from "@c15t/logger";
+import { createLogger as logger_createLogger } from "@c15t/logger";
 import { migrator } from "@c15t/backend/db/migrator";
 import { DB } from "@c15t/backend/db/schema";
 import { loadConfig as external_c12_loadConfig } from "c12";
@@ -83,14 +84,17 @@ __webpack_require__.r(config_store_namespaceObject);
 __webpack_require__.d(config_store_namespaceObject, {
     getAccessToken: ()=>config_store_getAccessToken,
     IM: ()=>getAuthState,
+    qs: ()=>getSelectedInstanceId,
+    M3: ()=>isLoggedIn,
     _g: ()=>setSelectedInstanceId,
     Ex: ()=>storeTokens
 });
 function showHelpMenu(context, version, commands, flags) {
     const { logger } = context;
     logger.debug('Displaying help menu using command and flag structures.');
-    const commandColumnWidth = Math.max(...commands.map((cmd)=>cmd.name.length), 10) + 2;
-    const commandLines = commands.map((cmd)=>`  ${cmd.name.padEnd(commandColumnWidth)}${cmd.description}`).join('\n');
+    const visibleCommands = commands.filter((cmd)=>!cmd.hidden);
+    const commandColumnWidth = Math.max(...visibleCommands.map((cmd)=>cmd.name.length), 10) + 2;
+    const commandLines = visibleCommands.map((cmd)=>`  ${cmd.name.padEnd(commandColumnWidth)}${cmd.description}`).join('\n');
     const flagDisplays = flags.map((flag)=>{
         const names = flag.names.join(', ');
         const valuePlaceholder = flag.expectsValue ? ' <value>' : '';
@@ -111,7 +115,7 @@ ${optionLines}
 
 Run a command directly (e.g., ${picocolors.cyan('c15t setup')}) or select one interactively when no command is provided.
 
-For more help, visit: https://v2.c15t.com`;
+For more help, visit: https://c15t.com`;
     logger.debug('Help menu content generated.');
     logger.note(helpContent, 'Usage');
 }
@@ -351,6 +355,191 @@ async function runActiveUiApiCodemod(options) {
         errors
     };
 }
+const CSS_ENTRYPOINT_CANDIDATES = [
+    'app/globals.css',
+    'src/app/globals.css',
+    'app/global.css',
+    'src/app/global.css',
+    'styles/globals.css',
+    'src/styles/globals.css',
+    'styles/global.css',
+    'src/styles/global.css',
+    'src/index.css',
+    'src/styles.css',
+    'src/style.css',
+    'styles.css',
+    'app.css',
+    'src/App.css'
+];
+const LOCAL_CSS_IMPORT_RE = /^\s*import(?:\s+[^'"]+\s+from\s+)?['"]([^'"]+\.css)['"];\s*$/gm;
+const TAILWIND_V4_IMPORT_RE = /^\s*@import\s+['"]tailwindcss['"];\s*$/;
+const TAILWIND_COMPONENTS_RE = /^\s*@tailwind\s+components\s*;\s*$/;
+const TAILWIND_UTILITIES_RE = /^\s*@tailwind\s+utilities\s*;\s*$/;
+function normalizePath(projectRoot, filePath) {
+    if (filePath.startsWith(projectRoot)) return filePath;
+    return external_node_path_resolve(projectRoot, filePath);
+}
+function dedupePaths(paths) {
+    return [
+        ...new Set(paths)
+    ];
+}
+function isNonModuleLocalCssImport(moduleSpecifier) {
+    return moduleSpecifier.startsWith('.') && moduleSpecifier.endsWith('.css') && !moduleSpecifier.endsWith('.module.css');
+}
+function getManagedPackages(packageName) {
+    if ('@c15t/react' === packageName || '@c15t/nextjs' === packageName) return [
+        '@c15t/react',
+        '@c15t/nextjs'
+    ];
+    return [
+        '@c15t/ui'
+    ];
+}
+function getImportVariants(packageName, kind) {
+    if ('base' === kind) return [
+        `${packageName}/styles.css`,
+        `${packageName}/styles.tw3.css`
+    ];
+    return [
+        `${packageName}/iab/styles.css`,
+        `${packageName}/iab/styles.tw3.css`
+    ];
+}
+function getDesiredImportPath(packageName, kind, tailwindVersion) {
+    const suffix = isTailwindV3(tailwindVersion) ? 'styles.tw3.css' : 'styles.css';
+    return 'base' === kind ? `${packageName}/${suffix}` : `${packageName}/iab/${suffix}`;
+}
+function getDesiredImports(packageName, tailwindVersion, includeBase, includeIab) {
+    const imports = [];
+    if (includeBase) imports.push(getDesiredImportPath(packageName, 'base', tailwindVersion));
+    if (includeIab) imports.push(getDesiredImportPath(packageName, 'iab', tailwindVersion));
+    return imports;
+}
+function getFrameworkImportRegex(packageNames) {
+    const escapedPackages = packageNames.map((packageName)=>packageName.replace('/', '\\/')).join('|');
+    return new RegExp(`^\\s*@import\\s+['"](?:${escapedPackages})(?:\\/iab)?\\/styles(?:\\.tw3)?\\.css['"];\\s*$`);
+}
+function findTopInsertionLineIndex(lines) {
+    let index = 0;
+    if (lines[index]?.trim().startsWith('/*')) {
+        while(index < lines.length){
+            const line = lines[index];
+            index += 1;
+            if (line?.includes('*/')) break;
+        }
+        while(index < lines.length && lines[index]?.trim() === '')index += 1;
+    }
+    return index;
+}
+function insertImportsIntoCssContent(content, desiredImports, tailwindVersion, managedPackages) {
+    const normalizedContent = content.replace(/\r\n/g, '\n');
+    const hadTrailingNewline = normalizedContent.endsWith('\n');
+    const body = hadTrailingNewline ? normalizedContent.slice(0, -1) : normalizedContent;
+    const lines = body.length > 0 ? body.split('\n') : [];
+    const importRegex = getFrameworkImportRegex(managedPackages);
+    const filteredLines = lines.filter((line)=>!importRegex.test(line));
+    const importLines = desiredImports.map((importPath)=>`@import "${importPath}";`);
+    let insertionIndex = findTopInsertionLineIndex(filteredLines);
+    if (isTailwindV3(tailwindVersion)) {
+        const componentsIndex = filteredLines.findIndex((line)=>TAILWIND_COMPONENTS_RE.test(line));
+        if (componentsIndex >= 0) insertionIndex = componentsIndex + 1;
+        else {
+            const utilitiesIndex = filteredLines.findIndex((line)=>TAILWIND_UTILITIES_RE.test(line));
+            if (utilitiesIndex >= 0) insertionIndex = utilitiesIndex;
+        }
+    } else {
+        const tailwindImportIndex = filteredLines.findIndex((line)=>TAILWIND_V4_IMPORT_RE.test(line));
+        if (tailwindImportIndex >= 0) insertionIndex = tailwindImportIndex + 1;
+    }
+    const nextLines = [
+        ...filteredLines.slice(0, insertionIndex),
+        ...importLines,
+        ...filteredLines.slice(insertionIndex)
+    ];
+    let nextContent = nextLines.join('\n');
+    if (hadTrailingNewline) nextContent += '\n';
+    if (content.includes('\r\n')) nextContent = nextContent.replace(/\n/g, '\r\n');
+    return nextContent;
+}
+function describeImportChange(content, packageName, desiredImportPath) {
+    const kind = desiredImportPath.includes('/iab/') ? 'iab' : 'base';
+    const variants = getImportVariants(packageName, kind);
+    const alternateVariant = variants.find((variant)=>variant !== desiredImportPath && content.includes(variant));
+    if (alternateVariant) return `replaced @import "${alternateVariant}"; with @import "${desiredImportPath}";`;
+    if (content.includes(desiredImportPath)) return `normalized @import "${desiredImportPath}";`;
+    return `added @import "${desiredImportPath}";`;
+}
+async function resolveCssEntrypoint({ projectRoot, entrypointPath }) {
+    const searchedPaths = [];
+    if (entrypointPath) {
+        const resolvedEntrypointPath = normalizePath(projectRoot, entrypointPath);
+        if (external_node_fs_existsSync(resolvedEntrypointPath)) {
+            const entrypointContent = await readFile(resolvedEntrypointPath, 'utf-8');
+            for (const match of entrypointContent.matchAll(LOCAL_CSS_IMPORT_RE)){
+                const moduleSpecifier = match[1];
+                if (!moduleSpecifier || !isNonModuleLocalCssImport(moduleSpecifier)) continue;
+                const candidatePath = external_node_path_resolve(dirname(resolvedEntrypointPath), moduleSpecifier);
+                searchedPaths.push(candidatePath);
+                if (external_node_fs_existsSync(candidatePath)) return {
+                    filePath: candidatePath,
+                    searchedPaths: dedupePaths(searchedPaths)
+                };
+            }
+        }
+    }
+    for (const candidate of CSS_ENTRYPOINT_CANDIDATES){
+        const candidatePath = external_node_path_join(projectRoot, candidate);
+        searchedPaths.push(candidatePath);
+        if (external_node_fs_existsSync(candidatePath)) return {
+            filePath: candidatePath,
+            searchedPaths: dedupePaths(searchedPaths)
+        };
+    }
+    return {
+        filePath: null,
+        searchedPaths: dedupePaths(searchedPaths)
+    };
+}
+function formatSearchedCssPaths(projectRoot, searchedPaths) {
+    return searchedPaths.map((filePath)=>relative(projectRoot, filePath) || '.').join(', ');
+}
+function isTailwindV3(version) {
+    return null != version && /^(?:\^|~)?3/.test(version);
+}
+async function ensureGlobalCssStylesheetImports(options) {
+    const desiredImports = getDesiredImports(options.packageName, options.tailwindVersion, options.includeBase, options.includeIab);
+    if (0 === desiredImports.length) return {
+        updated: false,
+        filePath: null,
+        searchedPaths: [],
+        changes: []
+    };
+    const { filePath, searchedPaths } = await resolveCssEntrypoint(options);
+    if (!filePath) return {
+        updated: false,
+        filePath: null,
+        searchedPaths,
+        changes: []
+    };
+    const content = await readFile(filePath, 'utf-8');
+    const managedPackages = getManagedPackages(options.packageName);
+    const nextContent = insertImportsIntoCssContent(content, desiredImports, options.tailwindVersion, managedPackages);
+    if (nextContent === content) return {
+        updated: false,
+        filePath,
+        searchedPaths,
+        changes: []
+    };
+    if (!options.dryRun) await writeFile(filePath, nextContent, 'utf-8');
+    const changes = desiredImports.map((importPath)=>describeImportChange(content, options.packageName, importPath));
+    return {
+        updated: true,
+        filePath,
+        searchedPaths,
+        changes
+    };
+}
 const add_stylesheet_imports_SUPPORTED_EXTENSIONS = new Set([
     '.ts',
     '.tsx',
@@ -400,6 +589,17 @@ const NEXTJS_ENTRYPOINTS = [
     'pages/_app.tsx',
     'pages/_app.jsx'
 ];
+async function detectTailwindVersion(projectRoot) {
+    const packageJsonPath = external_node_path_join(projectRoot, 'package.json');
+    if (!external_node_fs_existsSync(packageJsonPath)) return null;
+    try {
+        const content = await readFile(packageJsonPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        return parsed.dependencies?.tailwindcss ?? parsed.devDependencies?.tailwindcss ?? null;
+    } catch  {
+        return null;
+    }
+}
 async function add_stylesheet_imports_collectSourceFiles(rootDir) {
     const files = [];
     async function walk(currentDir) {
@@ -492,23 +692,19 @@ function findEntrypoint(projectRoot, framework) {
     }
     return null;
 }
-function hasCssImport(project, filePath, cssImportPath) {
+const FRAMEWORK_STYLESHEET_IMPORT_RE = /^@c15t\/(?:react|nextjs)(?:\/iab)?\/styles(?:\.tw3)?\.css$/;
+function removeFrameworkStylesheetImports(project, filePath) {
     const sourceFile = project.addSourceFileAtPathIfExists(filePath);
-    if (!sourceFile) return false;
-    const importDeclarations = sourceFile.getImportDeclarations();
-    return importDeclarations.some((importDecl)=>importDecl.getModuleSpecifierValue() === cssImportPath);
-}
-function addCssImport(project, filePath, cssImportPath) {
-    const sourceFile = project.addSourceFileAtPathIfExists(filePath);
-    if (!sourceFile) return false;
-    const importDeclarations = sourceFile.getImportDeclarations();
-    const alreadyExists = importDeclarations.some((importDecl)=>importDecl.getModuleSpecifierValue() === cssImportPath);
-    if (alreadyExists) return false;
-    if (importDeclarations.length > 0) {
-        const lastImport = importDeclarations[importDeclarations.length - 1];
-        if (lastImport) sourceFile.insertStatements(lastImport.getChildIndex() + 1, `import '${cssImportPath}';`);
-    } else sourceFile.insertStatements(0, `import '${cssImportPath}';`);
-    return true;
+    if (!sourceFile) return [];
+    const removedImports = [];
+    for (const importDeclaration of sourceFile.getImportDeclarations()){
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        if (FRAMEWORK_STYLESHEET_IMPORT_RE.test(moduleSpecifier)) {
+            removedImports.push(moduleSpecifier);
+            importDeclaration.remove();
+        }
+    }
+    return removedImports;
 }
 async function runAddStylesheetImportsCodemod(options) {
     const project = new Project({
@@ -550,40 +746,42 @@ async function runAddStylesheetImportsCodemod(options) {
         };
     }
     const pkg = 'nextjs' === detection.framework ? '@c15t/nextjs' : '@c15t/react';
-    const operations = [];
-    const summaries = [];
+    const tailwindVersion = await detectTailwindVersion(options.projectRoot);
     try {
-        if (detection.usesStyledUi) {
-            const baseCss = `${pkg}/styles.css`;
-            if (!hasCssImport(project, entrypoint, baseCss)) {
-                const added = addCssImport(project, entrypoint, baseCss);
-                if (added) {
-                    operations.push(1);
-                    summaries.push(`added import '${baseCss}'`);
-                }
-            }
-        }
-        if (detection.usesIabUi) {
-            const iabCss = `${pkg}/iab/styles.css`;
-            if (!hasCssImport(project, entrypoint, iabCss)) {
-                const added = addCssImport(project, entrypoint, iabCss);
-                if (added) {
-                    operations.push(1);
-                    summaries.push(`added import '${iabCss}'`);
-                }
-            }
+        const stylesheetResult = await ensureGlobalCssStylesheetImports({
+            projectRoot: options.projectRoot,
+            packageName: pkg,
+            tailwindVersion,
+            entrypointPath: entrypoint,
+            includeBase: detection.usesStyledUi || detection.usesIabUi,
+            includeIab: detection.usesIabUi,
+            dryRun: options.dryRun
+        });
+        if (!stylesheetResult.filePath) {
+            errors.push({
+                filePath: options.projectRoot,
+                error: `No suitable global CSS entrypoint found. Checked: ${formatSearchedCssPaths(options.projectRoot, stylesheetResult.searchedPaths)}`
+            });
+            return {
+                totalFiles: filePaths.length,
+                changedFiles,
+                errors
+            };
         }
-        if (operations.length > 0) {
-            changedFiles.push({
-                filePath: entrypoint,
-                operations: operations.length,
-                summaries
+        if (stylesheetResult.updated) changedFiles.push({
+            filePath: stylesheetResult.filePath,
+            operations: stylesheetResult.changes.length,
+            summaries: stylesheetResult.changes
+        });
+        for (const filePath of filePaths){
+            const removedImports = removeFrameworkStylesheetImports(project, filePath);
+            if (0 !== removedImports.length) changedFiles.push({
+                filePath,
+                operations: removedImports.length,
+                summaries: removedImports.map((importPath)=>`removed JS import '${importPath}'`)
             });
-            if (!options.dryRun) {
-                const sourceFile = project.getSourceFile(entrypoint);
-                if (sourceFile) await sourceFile.save();
-            }
         }
+        if (!options.dryRun) await project.save();
     } catch (error) {
         errors.push({
             filePath: entrypoint,
@@ -2113,8 +2311,8 @@ const codemods = [
     },
     {
         id: 'add-stylesheet-imports',
-        label: 'add stylesheet imports for prebuilt UI',
-        hint: 'Adds @c15t/react/styles.css or @c15t/nextjs/styles.css imports for styled components.',
+        label: 'configure global CSS for prebuilt UI',
+        hint: 'Moves styled c15t imports into the app CSS entrypoint, including Tailwind 3 and IAB variants when needed.',
         run: async (context, dryRun)=>{
             const { projectRoot } = context;
             const result = await runAddStylesheetImportsCodemod({
@@ -2173,7 +2371,95 @@ const codemodsCommand = {
     description: 'Run project codemods (for example translations -> i18n migration).',
     action: runCodemods
 };
-const TELEMETRY_DISABLED_ENV = 'C15T_TELEMETRY_DISABLED';
+const constants_URLS = {
+    CONSENT_IO: 'https://inth.com',
+    TELEMETRY: 'https://telemetry.c15t.com/c15t/v1/logs',
+    DOCS: 'https://c15t.com/docs',
+    GITHUB: 'https://github.com/c15t/c15t',
+    DISCORD: 'https://c15t.com/discord',
+    API_DOCS: 'https://c15t.com/docs/api',
+    CLI_DOCS: 'https://c15t.com/docs/cli',
+    CHANGELOG: 'https://c15t.com/changelog'
+};
+const PATHS = {
+    CONFIG_DIR: '.c15t',
+    CONFIG_FILE: 'config.json',
+    TELEMETRY_STATE_FILE: 'telemetry.json',
+    TELEMETRY_QUEUE_FILE: 'telemetry-queue.json',
+    PROJECT_CONFIG: 'c15t.config.ts',
+    PROJECT_CONFIG_JS: 'c15t.config.js',
+    ENV_FILE: '.env',
+    ENV_LOCAL: '.env.local'
+};
+const constants_REGEX = {
+    URL: /^https?:\/\/.+/,
+    C15T_URL: /^https:\/\/[\w-]+\.(?:c15t\.dev|inth\.app)$/,
+    DYNAMIC_SEGMENT: /\[[\w-]+\]/,
+    SEMVER: /^\d+\.\d+\.\d+(-[\w.]+)?$/,
+    PACKAGE_NAME: /^(@[\w-]+\/)?[\w-]+$/
+};
+const CLI_INFO = {
+    NAME: 'c15t',
+    BIN: 'c15t',
+    CONTROL_PLANE_CLIENT_NAME: 'c15t-cli',
+    VERSION: '2.0.0'
+};
+const TIMEOUTS = {
+    DEVICE_FLOW_POLL_INTERVAL: 5,
+    DEVICE_FLOW_EXPIRY: 900,
+    HTTP_REQUEST: 10000,
+    CONTROL_PLANE_CONNECTION: 30000
+};
+const ENV_VARS = {
+    V2: 'V2',
+    TELEMETRY_DISABLED: 'C15T_TELEMETRY_DISABLED',
+    TELEMETRY_ENDPOINT: 'C15T_TELEMETRY_ENDPOINT',
+    TELEMETRY_WRITE_KEY: 'C15T_TELEMETRY_WRITE_KEY',
+    TELEMETRY_ORG_ID: 'C15T_TELEMETRY_ORG_ID',
+    CONSENT_URL: 'CONSENT_URL',
+    BACKEND_URL: 'C15T_URL',
+    API_KEY: 'C15T_API_KEY',
+    DEBUG: 'C15T_DEBUG'
+};
+const STORAGE_MODES = {
+    HOSTED: 'hosted',
+    C15T: 'c15t',
+    OFFLINE: 'offline',
+    SELF_HOSTED: 'self-hosted',
+    CUSTOM: 'custom'
+};
+const LAYOUT_PATTERNS = [
+    'app/layout.tsx',
+    'app/layout.ts',
+    'app/layout.jsx',
+    'app/layout.js',
+    'src/app/layout.tsx',
+    'src/app/layout.ts',
+    'src/app/layout.jsx',
+    'src/app/layout.js',
+    'app/*/layout.tsx',
+    'app/*/layout.ts',
+    'app/*/layout.jsx',
+    'app/*/layout.js',
+    'src/app/*/layout.tsx',
+    'src/app/*/layout.ts',
+    'src/app/*/layout.jsx',
+    'src/app/*/layout.js',
+    'app/*/*/layout.tsx',
+    'app/*/*/layout.ts',
+    'src/app/*/*/layout.tsx',
+    'src/app/*/*/layout.ts'
+];
+const PAGES_APP_PATTERNS = [
+    'pages/_app.tsx',
+    'pages/_app.ts',
+    'pages/_app.jsx',
+    'pages/_app.js',
+    'src/pages/_app.tsx',
+    'src/pages/_app.ts',
+    'src/pages/_app.jsx',
+    'src/pages/_app.js'
+];
 const TelemetryEventName = {
     CLI_INVOKED: 'cli.invoked',
     CLI_COMPLETED: 'cli.completed',
@@ -2191,6 +2477,7 @@ const TelemetryEventName = {
     HELP_DISPLAYED: 'help.displayed',
     VERSION_DISPLAYED: 'version.displayed',
     ONBOARDING_STARTED: 'onboarding.started',
+    ONBOARDING_STAGE: 'onboarding.stage',
     ONBOARDING_COMPLETED: 'onboarding.completed',
     ONBOARDING_EXITED: 'onboarding.exited',
     ONBOARDING_STORAGE_MODE_SELECTED: 'onboarding.storage_mode_selected',
@@ -2201,6 +2488,13 @@ const TelemetryEventName = {
     ONBOARDING_DEPENDENCIES_CHOICE: 'onboarding.dependencies_choice',
     ONBOARDING_DEPENDENCIES_INSTALLED: 'onboarding.dependencies_installed',
     ONBOARDING_GITHUB_STAR: 'onboarding.github_star',
+    AUTH_LOGIN_STARTED: 'auth.login.started',
+    AUTH_LOGIN_SUCCEEDED: 'auth.login.succeeded',
+    AUTH_LOGIN_FAILED: 'auth.login.failed',
+    AUTH_LOGOUT: 'auth.logout',
+    PROJECTS_LISTED: 'projects.listed',
+    PROJECT_SELECTED: 'project.selected',
+    PROJECT_CREATED: 'project.created',
     ERROR_OCCURRED: 'error.occurred',
     MIGRATION_STARTED: 'migration.started',
     MIGRATION_PLANNED: 'migration.planned',
@@ -2218,178 +2512,408 @@ const TelemetryEventName = {
     CLI_STATE_CANCELLED: 'cli.state.cancelled',
     CLI_STATE_COMPLETE: 'cli.state.complete'
 };
+const DEFAULT_QUEUE_LIMIT = 250;
+const DEFAULT_TIMEOUT_MS = 3000;
+const DEFAULT_BATCH_SIZE = 20;
+const DEFAULT_BATCH_INTERVAL_MS = 1000;
+const DEFAULT_MAX_BUFFER_SIZE = 250;
+const MAX_DEPTH = 5;
+const MAX_ARRAY_LENGTH = 20;
+const MAX_OBJECT_KEYS = 50;
+const MAX_STRING_LENGTH = 500;
+const RESERVED_TOP_LEVEL_KEYS = new Set([
+    'event',
+    'installId',
+    'sessionId',
+    'commandRunId',
+    'sequence',
+    'source'
+]);
+const SENSITIVE_KEY_PATTERN = /(^|[-_])(token|secret|password|authorization|cookie|api[-_]?key|access[-_]?token|refresh[-_]?token|config)([-_]|$)/i;
+const SECRET_VALUE_PATTERN = /^(Bearer\s+[A-Za-z0-9._-]+|[A-Za-z0-9+/=_-]{80,})$/;
 class Telemetry {
-    client = null;
-    disabled;
+    endpoint;
+    fetchImpl;
+    queuePath;
+    statePath;
+    headers;
     defaultProperties;
-    distinctId;
-    apiKey = 'phc_ViY5LtTmh4kqoumXZB2olPFoTz4AbbDfrogNgFi1MH3';
-    debug;
+    sessionId = node_crypto.randomUUID();
+    installId;
+    isFirstRun;
+    drain;
+    storageDir;
     logger;
+    disabled;
+    debug;
+    sequence = 0;
+    activeCommandName;
+    activeCommandRunId;
+    flushPromise = null;
+    queueReplayPromise = Promise.resolve();
+    queueWritePromise = Promise.resolve();
     constructor(options){
-        const envDisabled = '1' === process.env[TELEMETRY_DISABLED_ENV] || process.env[TELEMETRY_DISABLED_ENV]?.toLowerCase() === 'true';
-        const hasValidApiKey = !!(this.apiKey && '' !== this.apiKey.trim());
-        this.disabled = options?.disabled ?? envDisabled ?? !hasValidApiKey;
-        this.defaultProperties = options?.defaultProperties ?? {};
-        this.logger = options?.logger;
+        const envDisabled = '1' === process.env[ENV_VARS.TELEMETRY_DISABLED] || process.env[ENV_VARS.TELEMETRY_DISABLED]?.toLowerCase() === 'true';
+        this.disabled = options?.disabled ?? envDisabled ?? false;
         this.debug = options?.debug ?? false;
-        this.distinctId = this.generateAnonymousId();
-        if (this.disabled) {
-            if (!hasValidApiKey) this.logDebug('Telemetry disabled: No API key provided');
-        } else try {
-            this.initClient(options?.client);
-        } catch (error) {
-            this.disabled = true;
-            this.logDebug('Telemetry disabled due to initialization error:', error);
-        }
+        this.logger = options?.logger;
+        this.defaultProperties = this.sanitizeProperties(options?.defaultProperties ?? {});
+        this.endpoint = options?.endpoint ?? process.env[ENV_VARS.TELEMETRY_ENDPOINT] ?? constants_URLS.TELEMETRY;
+        this.fetchImpl = options?.fetch ?? fetch;
+        this.storageDir = options?.storageDir ?? node_path.join(node_os.homedir(), PATHS.CONFIG_DIR);
+        this.statePath = node_path.join(this.storageDir, PATHS.TELEMETRY_STATE_FILE);
+        this.queuePath = node_path.join(this.storageDir, PATHS.TELEMETRY_QUEUE_FILE);
+        this.headers = this.buildHeaders(options?.headers);
+        const identity = this.loadOrCreateInstallIdentity();
+        this.installId = identity.installId;
+        this.isFirstRun = identity.isFirstRun;
+        const userDrainOptions = options?.drainOptions;
+        const onDropped = userDrainOptions?.onDropped;
+        const pipeline = createDrainPipeline({
+            batch: {
+                size: userDrainOptions?.batch?.size ?? DEFAULT_BATCH_SIZE,
+                intervalMs: userDrainOptions?.batch?.intervalMs ?? DEFAULT_BATCH_INTERVAL_MS
+            },
+            retry: {
+                maxAttempts: userDrainOptions?.retry?.maxAttempts ?? 2,
+                backoff: userDrainOptions?.retry?.backoff ?? 'fixed',
+                initialDelayMs: userDrainOptions?.retry?.initialDelayMs ?? 250,
+                maxDelayMs: userDrainOptions?.retry?.maxDelayMs ?? 1000
+            },
+            maxBufferSize: userDrainOptions?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE,
+            onDropped: (events, error)=>{
+                onDropped?.(events, error);
+                this.persistDroppedEvents(events, error);
+            }
+        });
+        this.drain = pipeline(async (batch)=>{
+            await this.sendBatch(batch.map((item)=>item.event));
+        });
+        this.applyLoggerConfig();
+        this.queueReplayPromise = this.flushQueuedEvents();
     }
     trackEvent(eventName, properties = {}) {
-        if (this.disabled || !this.client) {
-            if (this.debug) this.logDebug(`Telemetry event skipped (${eventName}): Telemetry disabled or client not initialized`);
-            return;
-        }
-        try {
-            const safeProperties = {};
-            for (const [key, value] of Object.entries(properties))if ('config' !== key && void 0 !== value) safeProperties[key] = value;
-            if (this.debug) this.logDebug(`Sending telemetry event: ${eventName}`);
-            this.client.capture({
-                distinctId: this.distinctId,
-                event: eventName,
-                properties: {
-                    ...this.defaultProperties,
-                    ...safeProperties,
-                    timestamp: new Date().toISOString()
-                }
-            });
-            this.client.flush();
-        } catch (error) {
-            if (this.debug) this.logDebug(`Error sending telemetry event ${eventName}:`, error);
-        }
-    }
-    trackEventSync(eventName, properties = {}) {
-        if (this.disabled || !this.client) {
-            if (this.debug) this.logDebug('Telemetry disabled or client not initialized');
+        if (this.disabled) {
+            if (this.debug) this.logDebug(`Telemetry event skipped (${eventName}): telemetry disabled`);
             return;
         }
-        const safeProperties = {};
-        for (const [key, value] of Object.entries(properties))if ('config' !== key && void 0 !== value) safeProperties[key] = value;
-        if (this.debug) this.logDebug(`Sending telemetry event: ${eventName}`);
         try {
-            this.client.capture({
-                distinctId: this.distinctId,
-                event: eventName,
-                properties: {
-                    ...this.defaultProperties,
-                    ...safeProperties,
-                    timestamp: new Date().toISOString()
-                }
-            });
-            this.client.flush();
-            if (this.debug) this.logDebug(`Flushed telemetry event: ${eventName}`);
+            const log = createLogger(this.buildBaseContext(eventName));
+            log.set(this.sanitizeProperties(properties));
+            log.emit();
+            if (this.debug) this.logDebug(`Queued telemetry event: ${eventName}`);
         } catch (error) {
-            if (this.debug) this.logDebug(`Error sending telemetry: ${error}`);
+            if (this.debug) this.logDebug(`Failed to queue telemetry event ${eventName}:`, error);
         }
     }
     trackCommand(command, args = [], flags = {}) {
-        if (this.disabled || !this.client) return;
-        const safeFlags = {};
-        for (const [key, value] of Object.entries(flags))if ('config' !== key && void 0 !== value) safeFlags[key] = value;
+        this.activeCommandName = command;
+        this.activeCommandRunId = node_crypto.randomUUID();
+        const safeFlags = this.sanitizeProperties(flags);
+        const safeArgs = this.sanitizeValue(args);
         this.trackEvent(TelemetryEventName.COMMAND_EXECUTED, {
             command,
-            args: args.join(' '),
-            flagsData: JSON.stringify(safeFlags)
+            commandRunId: this.activeCommandRunId,
+            args: safeArgs,
+            argsCount: args.length,
+            flags: safeFlags,
+            flagCount: Object.keys(safeFlags).length,
+            flagNames: Object.keys(safeFlags).sort(),
+            subcommand: 'string' == typeof safeArgs[0] ? safeArgs[0] : void 0
         });
     }
     trackError(error, command) {
-        if (this.disabled || !this.client) return;
-        this.trackEvent(TelemetryEventName.ERROR_OCCURRED, {
-            command,
-            error: error.message,
-            errorName: error.name,
-            stack: 'development' === process.env.NODE_ENV ? error.stack : void 0
-        });
+        if (this.disabled) return;
+        const safeCommand = command ?? this.activeCommandName;
+        const safeError = this.sanitizeError(error);
+        const errorMetadata = this.buildErrorMetadata(error);
+        try {
+            const log = createLogger(this.buildBaseContext(TelemetryEventName.ERROR_OCCURRED));
+            log.error(safeError, {
+                command: safeCommand,
+                commandRunId: this.activeCommandRunId,
+                failure: errorMetadata
+            });
+            log.emit();
+            if (this.debug) this.logDebug(`Queued telemetry error event: ${safeCommand ?? 'unknown-command'}`);
+        } catch (trackingError) {
+            if (this.debug) this.logDebug('Failed to queue telemetry error event:', trackingError);
+        }
     }
-    disable() {
-        this.disabled = true;
+    flushSync() {
+        if (this.disabled) return;
+        this.flushPromise = this.flushAll();
     }
-    enable() {
-        this.disabled = false;
-        if (!this.client) this.initClient();
+    async shutdown() {
+        if (this.disabled) return;
+        await (this.flushPromise ?? this.flushAll());
     }
     isDisabled() {
         return this.disabled;
     }
-    async shutdown() {
-        if (this.client) {
-            await this.client.shutdown();
-            this.client = null;
-        }
+    disable() {
+        this.disabled = true;
+        this.applyLoggerConfig();
+    }
+    enable() {
+        this.disabled = false;
+        this.applyLoggerConfig();
+        this.queueReplayPromise = this.flushQueuedEvents();
     }
     setLogger(logger) {
         this.logger = logger;
     }
-    logDebug(message, ...args) {
-        if (this.logger) this.logger.debug(message, ...args);
-        else console.debug(message, ...args);
+    applyLoggerConfig() {
+        const cliVersion = this.readString(this.defaultProperties.cliVersion);
+        initLogger({
+            enabled: !this.disabled,
+            silent: true,
+            pretty: false,
+            stringify: false,
+            _suppressDrainWarning: this.disabled,
+            env: {
+                service: 'c15t-cli',
+                environment: this.getEnvironmentName(),
+                version: cliVersion
+            },
+            drain: this.disabled ? void 0 : this.drain
+        });
     }
-    initClient(customClient) {
-        if (customClient) {
-            this.client = customClient;
-            if (this.debug) this.logDebug('Using custom PostHog client');
-        } else {
-            if (!this.apiKey || '' === this.apiKey.trim()) {
-                this.disabled = true;
-                this.logDebug('Telemetry disabled: No API key provided');
-                return;
-            }
-            const startTime = Date.now();
+    buildBaseContext(eventName) {
+        this.sequence += 1;
+        return {
+            event: eventName,
+            source: 'c15t-cli',
+            installId: this.installId,
+            sessionId: this.sessionId,
+            commandRunId: this.activeCommandRunId,
+            command: this.activeCommandName,
+            sequence: this.sequence,
+            firstRun: this.isFirstRun,
+            interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+            tty: Boolean(process.stdout.isTTY),
+            ci: this.isCi(),
+            platform: process.platform,
+            arch: process.arch,
+            nodeVersion: process.version,
+            ...this.defaultProperties
+        };
+    }
+    buildHeaders(overrides) {
+        const writeKey = process.env[ENV_VARS.TELEMETRY_WRITE_KEY];
+        const orgId = process.env[ENV_VARS.TELEMETRY_ORG_ID];
+        return {
+            'Content-Type': 'application/json',
+            ...writeKey ? {
+                Authorization: `Bearer ${writeKey}`
+            } : {},
+            ...orgId ? {
+                'X-Axiom-Org-Id': orgId
+            } : {},
+            ...overrides
+        };
+    }
+    async flushAll() {
+        try {
+            await this.queueReplayPromise;
+            await this.drain.flush();
+            await this.queueWritePromise;
+            await this.flushQueuedEvents();
+            if (this.debug) this.logDebug('Flushed telemetry events');
+        } catch (error) {
+            if (this.debug) this.logDebug('Telemetry flush failed:', error);
+        } finally{
+            this.flushPromise = null;
+        }
+    }
+    async sendBatch(events) {
+        if (0 === events.length) return;
+        const controller = new AbortController();
+        const timeout = setTimeout(()=>controller.abort(), DEFAULT_TIMEOUT_MS);
+        try {
+            const response = await this.fetchImpl(this.endpoint, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify(events),
+                signal: controller.signal
+            });
+            if (!response.ok) throw new Error(`Telemetry ingest failed with status ${response.status}`);
+        } finally{
+            clearTimeout(timeout);
+        }
+    }
+    async persistDroppedEvents(events, error) {
+        this.queueWritePromise = this.queueWritePromise.then(async ()=>{
             try {
-                const clientConfig = {
-                    host: 'https://eu.i.posthog.com',
-                    flushInterval: 0,
-                    flushAt: 1,
-                    requestTimeout: 3000
-                };
-                if (this.debug) this.logDebug('Initializing PostHog client with config:', JSON.stringify(clientConfig));
-                this.client = new PostHog(this.apiKey, clientConfig);
-                const initTime = Date.now() - startTime;
-                if (this.debug) this.logDebug('PostHog client initialized in', initTime, 'ms');
-            } catch (error) {
-                this.disabled = true;
-                const errorDetails = error instanceof Error ? {
-                    message: error.message,
-                    name: error.name,
-                    stack: error.stack
-                } : {
-                    rawError: String(error)
-                };
-                if (this.debug) this.logDebug('Telemetry disabled due to initialization error:', JSON.stringify(errorDetails, null, 2));
-                try {
-                    if (this.debug) this.logDebug('Attempting fallback PostHog initialization');
-                    this.client = new PostHog(this.apiKey);
-                    this.disabled = false;
-                    if (this.debug) this.logDebug('PostHog client initialized using fallback method');
-                } catch (fallbackError) {
-                    this.logDebug('Fallback initialization also failed:', fallbackError instanceof Error ? fallbackError.message : String(fallbackError));
-                }
+                const existing = await this.readQueuedEvents();
+                const next = [
+                    ...existing,
+                    ...events.map((item)=>item.event)
+                ].slice(-DEFAULT_QUEUE_LIMIT);
+                await this.writeQueuedEvents(next);
+                if (this.debug) this.logDebug(`Persisted ${events.length} dropped telemetry event(s) to disk`, error);
+            } catch (queueError) {
+                if (this.debug) this.logDebug('Failed to persist dropped telemetry events:', queueError);
             }
+        });
+        await this.queueWritePromise;
+    }
+    async flushQueuedEvents() {
+        if (this.disabled) return;
+        try {
+            const queuedEvents = await this.readQueuedEvents();
+            if (0 === queuedEvents.length) return;
+            await this.sendBatch(queuedEvents);
+            await promises.unlink(this.queuePath).catch(()=>void 0);
+            if (this.debug) this.logDebug(`Replayed ${queuedEvents.length} queued telemetry event(s)`);
+        } catch (error) {
+            if (this.debug) this.logDebug('Failed to replay queued telemetry events:', error);
         }
     }
-    generateAnonymousId() {
-        const machineId = node_crypto.createHash('sha256').update(node_os.hostname() + node_os.platform() + node_os.arch() + node_os.totalmem()).digest('hex');
-        return machineId;
+    async readQueuedEvents() {
+        try {
+            const content = await promises.readFile(this.queuePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            if (!Array.isArray(parsed)) return [];
+            return parsed.filter((item)=>'object' == typeof item && null !== item);
+        } catch  {
+            return [];
+        }
     }
-    flushSync() {
-        if (this.disabled || !this.client) return;
+    async writeQueuedEvents(events) {
+        await promises.mkdir(this.storageDir, {
+            recursive: true
+        });
+        await promises.writeFile(this.queuePath, JSON.stringify(events, null, 2), {
+            mode: 384
+        });
+    }
+    loadOrCreateInstallIdentity() {
+        try {
+            node_fs.mkdirSync(this.storageDir, {
+                recursive: true
+            });
+            if (node_fs.existsSync(this.statePath)) {
+                const content = node_fs.readFileSync(this.statePath, 'utf-8');
+                const parsed = JSON.parse(content);
+                if ('string' == typeof parsed.installId && parsed.installId.length > 0) return {
+                    installId: parsed.installId,
+                    isFirstRun: false
+                };
+            }
+        } catch (error) {
+            if (this.debug) this.logDebug('Failed to read telemetry state file:', error);
+        }
+        const installId = node_crypto.randomUUID();
         try {
-            this.client.flush();
-            if (this.debug) this.logDebug('Manually flushed telemetry events');
+            node_fs.writeFileSync(this.statePath, JSON.stringify({
+                installId,
+                createdAt: new Date().toISOString()
+            }, null, 2), {
+                mode: 384
+            });
         } catch (error) {
-            if (this.debug) this.logDebug(`Error flushing telemetry: ${error}`);
+            if (this.debug) this.logDebug('Failed to persist telemetry install ID:', error);
+        }
+        return {
+            installId,
+            isFirstRun: true
+        };
+    }
+    buildErrorMetadata(error) {
+        const eventError = error;
+        return this.sanitizeProperties({
+            name: eventError.name,
+            message: eventError.message,
+            code: 'string' == typeof eventError.code || 'number' == typeof eventError.code ? eventError.code : void 0,
+            status: 'number' == typeof eventError.status ? eventError.status : void 0,
+            statusCode: 'number' == typeof eventError.statusCode ? eventError.statusCode : void 0,
+            cause: eventError.cause instanceof Error ? eventError.cause.message : 'string' == typeof eventError.cause ? eventError.cause : void 0
+        });
+    }
+    sanitizeError(error) {
+        const safeError = new Error(error.message);
+        safeError.name = error.name;
+        if ('development' === process.env.NODE_ENV) safeError.stack = error.stack;
+        else delete safeError.stack;
+        const sourceError = error;
+        const targetError = safeError;
+        if ('number' == typeof sourceError.status) targetError.status = sourceError.status;
+        if ('number' == typeof sourceError.statusCode) targetError.statusCode = sourceError.statusCode;
+        if ('string' == typeof sourceError.statusText) targetError.statusText = sourceError.statusText;
+        if ('string' == typeof sourceError.statusMessage) targetError.statusMessage = sourceError.statusMessage;
+        if (sourceError.cause instanceof Error) targetError.cause = sourceError.cause.message;
+        else if ('string' == typeof sourceError.cause) targetError.cause = sourceError.cause;
+        return safeError;
+    }
+    sanitizeProperties(properties) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(properties))if (!RESERVED_TOP_LEVEL_KEYS.has(key)) {
+            if (void 0 !== value) {
+                if (SENSITIVE_KEY_PATTERN.test(key)) {
+                    sanitized[key] = '[redacted]';
+                    continue;
+                }
+                sanitized[key] = this.sanitizeValue(value, 0, key);
+            }
+        }
+        return sanitized;
+    }
+    sanitizeValue(value, depth = 0, keyHint) {
+        if (depth >= MAX_DEPTH) return '[truncated]';
+        if (null === value) return null;
+        if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value) return this.sanitizePrimitive(value, keyHint);
+        if (value instanceof Date) return value.toISOString();
+        if (value instanceof Error) return this.sanitizeProperties(this.buildErrorMetadata(value));
+        if (Array.isArray(value)) return value.slice(0, MAX_ARRAY_LENGTH).map((item)=>this.sanitizeValue(item, depth + 1));
+        if ('object' == typeof value) {
+            const objectValue = value;
+            const sanitizedObject = {};
+            for (const key of Object.keys(objectValue).slice(0, MAX_OBJECT_KEYS)){
+                const nextValue = objectValue[key];
+                if (void 0 !== nextValue) {
+                    if (SENSITIVE_KEY_PATTERN.test(key)) {
+                        sanitizedObject[key] = '[redacted]';
+                        continue;
+                    }
+                    sanitizedObject[key] = this.sanitizeValue(nextValue, depth + 1, key);
+                }
+            }
+            return sanitizedObject;
         }
+        return String(value);
+    }
+    sanitizePrimitive(value, keyHint) {
+        if ('string' != typeof value) return value;
+        if (keyHint && SENSITIVE_KEY_PATTERN.test(keyHint)) return '[redacted]';
+        if (SECRET_VALUE_PATTERN.test(value)) return '[redacted]';
+        if (node_path.isAbsolute(value)) return '[absolute-path]';
+        if (value.startsWith('http://') || value.startsWith('https://')) try {
+            const parsed = new URL(value);
+            parsed.username = '';
+            parsed.password = '';
+            parsed.search = '';
+            parsed.hash = '';
+            value = parsed.toString();
+        } catch  {}
+        if (value.length > MAX_STRING_LENGTH) return `${value.slice(0, MAX_STRING_LENGTH)}...`;
+        return value;
+    }
+    getEnvironmentName() {
+        return process.env.NODE_ENV ?? (this.isCi() ? 'production' : 'development');
+    }
+    isCi() {
+        return Boolean(process.env.CI || process.env.GITHUB_ACTIONS || process.env.BUILDKITE || process.env.VERCEL);
+    }
+    readString(value) {
+        return 'string' == typeof value ? value : void 0;
+    }
+    logDebug(message, ...args) {
+        if (this.logger) this.logger.debug(message, ...args);
+        else console.debug(message, ...args);
     }
 }
-function createTelemetry(options) {
+function telemetry_createTelemetry(options) {
     return new Telemetry(options);
 }
 const DEFAULT_PERSIST_FILENAME = '.c15t-state.json';
@@ -2484,6 +3008,86 @@ function createPersistenceSubscriber(machineId, persistPath, options = {}) {
         });
     };
 }
+const GENERATE_STAGE_NAMES = {
+    preflight: 'preflight',
+    preflightError: 'preflight',
+    modeSelection: 'mode_selection',
+    hostedMode: 'hosted_mode',
+    offlineMode: 'offline_mode',
+    customMode: 'custom_mode',
+    backendOptions: 'backend_options',
+    frontendOptions: 'frontend_options',
+    scriptsOptions: "scripts_options",
+    fileGeneration: 'file_generation',
+    dependencyCheck: 'dependency_check',
+    dependencyConfirm: 'dependency_confirm',
+    dependencyInstall: 'dependency_install',
+    summary: 'summary',
+    skillsInstall: 'skills_install',
+    githubStar: 'github_star',
+    cancelling: 'cancelling',
+    cleanup: 'cleanup',
+    complete: 'complete',
+    error: 'error',
+    exited: 'exited',
+    cancelled: 'cancelled'
+};
+function normalizeGenerateStageName(state) {
+    return GENERATE_STAGE_NAMES[state] ?? state.replace(/[A-Z]/g, (char)=>`_${char.toLowerCase()}`);
+}
+function getGenerateContext(snapshot) {
+    return snapshot.context;
+}
+function normalizeCancelReason(reason) {
+    if (!reason) return 'user_cancelled';
+    const normalized = reason.toLowerCase();
+    if (normalized.includes('signal')) return 'signal_interrupted';
+    if (normalized.includes('mode selection')) return 'mode_selection_cancelled';
+    if (normalized.includes('hosted setup')) return 'hosted_setup_cancelled';
+    if (normalized.includes('backend options')) return 'backend_options_cancelled';
+    if (normalized.includes('frontend options')) return 'frontend_options_cancelled';
+    if (normalized.includes("scripts option")) return "scripts_options_cancelled";
+    if (normalized.includes('dependency')) return 'dependency_install_cancelled';
+    if (normalized.includes('prompt cancelled at stage:')) return normalized.replace('prompt cancelled at stage:', '').trim().replace(/\s+/g, '_').concat('_cancelled');
+    return 'user_cancelled';
+}
+function getStageReason(fromState, toState, context) {
+    if ('preflightError' === toState) return 'preflight_failed';
+    if ('cancelling' === toState || 'cancelled' === toState || 'exited' === toState) return normalizeCancelReason(context?.cancelReason);
+    if ('dependencyInstall' === fromState && context?.installSucceeded === false) return 'dependency_install_failed';
+    if ('error' === toState) {
+        const lastError = context?.errors?.[context.errors.length - 1];
+        if (lastError?.state === 'fileGeneration') return 'file_generation_failed';
+        if (lastError?.error?.name === 'PromptCancelledError') return normalizeCancelReason(lastError.error.message);
+        if (lastError?.state) return `${normalizeGenerateStageName(lastError.state)}_failed`;
+        return 'machine_error';
+    }
+}
+function getStageResult(fromState, toState, context) {
+    if ('preflightError' === toState || 'error' === toState) return 'failed';
+    if ('cancelling' === toState || 'cancelled' === toState || 'exited' === toState) return 'cancelled';
+    if ('dependencyInstall' === fromState && context?.installSucceeded === false) return 'failed';
+    return 'completed';
+}
+function buildGenerateStageTelemetry(fromState, toState, durationMs, snapshot) {
+    const context = getGenerateContext(snapshot);
+    return {
+        stage: normalizeGenerateStageName(fromState),
+        nextStage: normalizeGenerateStageName(toState),
+        durationMs,
+        result: getStageResult(fromState, toState, context),
+        reason: getStageReason(fromState, toState, context),
+        selectedMode: context?.selectedMode ?? void 0,
+        hostedProvider: context?.hostedProvider ?? void 0,
+        dependencyCount: context?.dependenciesToAdd?.length ?? 0,
+        filesCreatedCount: context?.filesCreated?.length ?? 0,
+        filesModifiedCount: context?.filesModified?.length ?? 0,
+        installConfirmed: context?.installConfirmed ?? void 0,
+        installAttempted: context?.installAttempted ?? void 0,
+        installSucceeded: context?.installSucceeded ?? void 0,
+        errorsCount: context?.errors?.length ?? 0
+    };
+}
 function createTelemetrySubscriber(config) {
     const { telemetry, machineId, skipStates = [] } = config;
     let lastState = null;
@@ -2502,6 +3106,7 @@ function createTelemetrySubscriber(config) {
                 toState: currentState,
                 duration
             });
+            if ('generate' === machineId) telemetry.trackEvent(TelemetryEventName.ONBOARDING_STAGE, buildGenerateStageTelemetry(lastState, currentState, duration, snapshot));
         }
         stateHistory.push({
             state: currentState,
@@ -2556,89 +3161,6 @@ function createDebugSubscriber(machineId, logger) {
         }
     };
 }
-const constants_URLS = {
-    CONSENT_IO: 'https://consent.io',
-    DOCS: 'https://v2.c15t.com/docs',
-    GITHUB: 'https://github.com/c15t/c15t',
-    DISCORD: 'https://v2.c15t.com/discord',
-    API_DOCS: 'https://v2.c15t.com/docs/api',
-    CLI_DOCS: 'https://v2.c15t.com/docs/cli',
-    CHANGELOG: 'https://v2.c15t.com/changelog'
-};
-const PATHS = {
-    CONFIG_DIR: '.c15t',
-    CONFIG_FILE: 'config.json',
-    PROJECT_CONFIG: 'c15t.config.ts',
-    PROJECT_CONFIG_JS: 'c15t.config.js',
-    ENV_FILE: '.env',
-    ENV_LOCAL: '.env.local'
-};
-const constants_REGEX = {
-    URL: /^https?:\/\/.+/,
-    C15T_URL: /^https:\/\/[\w-]+\.c15t\.dev$/,
-    DYNAMIC_SEGMENT: /\[[\w-]+\]/,
-    SEMVER: /^\d+\.\d+\.\d+(-[\w.]+)?$/,
-    PACKAGE_NAME: /^(@[\w-]+\/)?[\w-]+$/
-};
-const CLI_INFO = {
-    NAME: 'c15t',
-    BIN: 'c15t',
-    CONTROL_PLANE_CLIENT_NAME: 'c15t-cli',
-    VERSION: '2.0.0'
-};
-const TIMEOUTS = {
-    DEVICE_FLOW_POLL_INTERVAL: 5,
-    DEVICE_FLOW_EXPIRY: 900,
-    HTTP_REQUEST: 10000,
-    CONTROL_PLANE_CONNECTION: 30000
-};
-const ENV_VARS = {
-    V2: 'V2',
-    TELEMETRY_DISABLED: 'C15T_TELEMETRY_DISABLED',
-    CONSENT_URL: 'CONSENT_URL',
-    BACKEND_URL: 'C15T_URL',
-    API_KEY: 'C15T_API_KEY',
-    DEBUG: 'C15T_DEBUG'
-};
-const STORAGE_MODES = {
-    HOSTED: 'hosted',
-    C15T: 'c15t',
-    OFFLINE: 'offline',
-    SELF_HOSTED: 'self-hosted',
-    CUSTOM: 'custom'
-};
-const LAYOUT_PATTERNS = [
-    'app/layout.tsx',
-    'app/layout.ts',
-    'app/layout.jsx',
-    'app/layout.js',
-    'src/app/layout.tsx',
-    'src/app/layout.ts',
-    'src/app/layout.jsx',
-    'src/app/layout.js',
-    'app/*/layout.tsx',
-    'app/*/layout.ts',
-    'app/*/layout.jsx',
-    'app/*/layout.js',
-    'src/app/*/layout.tsx',
-    'src/app/*/layout.ts',
-    'src/app/*/layout.jsx',
-    'src/app/*/layout.js',
-    'app/*/*/layout.tsx',
-    'app/*/*/layout.ts',
-    'src/app/*/*/layout.tsx',
-    'src/app/*/*/layout.ts'
-];
-const PAGES_APP_PATTERNS = [
-    'pages/_app.tsx',
-    'pages/_app.ts',
-    'pages/_app.jsx',
-    'pages/_app.js',
-    'src/pages/_app.tsx',
-    'src/pages/_app.ts',
-    'src/pages/_app.jsx',
-    'src/pages/_app.js'
-];
 const ERROR_CATALOG = {
     AUTH_FAILED: {
         code: 'AUTH_FAILED',
@@ -2715,7 +3237,7 @@ const ERROR_CATALOG = {
     },
     CONTROL_PLANE_CONNECTION_FAILED: {
         code: 'CONTROL_PLANE_CONNECTION_FAILED',
-        message: 'Could not connect to consent.io',
+        message: 'Could not connect to inth.com',
         hint: `Check if ${constants_URLS.CONSENT_IO} is accessible`
     },
     API_ERROR: {
@@ -2726,17 +3248,17 @@ const ERROR_CATALOG = {
     URL_INVALID: {
         code: 'URL_INVALID',
         message: 'Invalid URL format',
-        hint: 'Expected format: https://your-instance.c15t.dev'
+        hint: 'Expected format: https://your-project.inth.app'
     },
     INSTANCE_NOT_FOUND: {
         code: 'INSTANCE_NOT_FOUND',
-        message: 'Instance not found',
-        hint: 'Run `c15t instances list` to see available instances'
+        message: 'Project not found',
+        hint: 'Run `c15t projects list` to see available projects'
     },
     INSTANCE_NAME_INVALID: {
         code: 'INSTANCE_NAME_INVALID',
-        message: 'Invalid instance name',
-        hint: 'Instance names must be alphanumeric with hyphens'
+        message: 'Invalid project slug',
+        hint: 'Project slugs must be alphanumeric with hyphens'
     },
     FILE_NOT_FOUND: {
         code: 'FILE_NOT_FOUND',
@@ -3255,11 +3777,19 @@ async function getAuthState() {
         isExpired: isTokenExpired(config)
     };
 }
+async function isLoggedIn() {
+    const state = await getAuthState();
+    return state.isLoggedIn && !state.isExpired;
+}
 async function config_store_getAccessToken() {
     const config = await loadConfig();
     if (!config || isTokenExpired(config)) return null;
     return config.accessToken;
 }
+async function getSelectedInstanceId() {
+    const config = await loadConfig();
+    return config?.selectedInstanceId || null;
+}
 async function setSelectedInstanceId(instanceId) {
     await updateConfig({
         selectedInstanceId: instanceId
@@ -3508,7 +4038,7 @@ function sleep(ms) {
 async function getDevToolsOption({ context, handleCancel, onCancel }) {
     const isReactProject = '@c15t/react' === context.framework.pkg || '@c15t/nextjs' === context.framework.pkg;
     context.logger.info("c15t DevTools helps you inspect consent state, scripts, and location overrides during development.");
-    context.logger.info('Learn more: https://v2.c15t.com/docs/dev-tools/overview');
+    context.logger.info('Learn more: https://c15t.com/docs/dev-tools/overview');
     const enableDevTools = await __rspack_external__clack_prompts_3cae1695.select({
         message: 'Install and enable c15t DevTools?',
         options: [
@@ -3539,7 +4069,7 @@ async function getSSROption({ context, handleCancel, onCancel }) {
     context.logger.info('SSR consent prefetch starts data loading on the server for faster banner visibility.');
     context.logger.info('Tradeoff: this uses Next.js headers() and makes the route dynamic (not fully static).');
     context.logger.info('On slow backends or cross-region setups, SSR can increase TTFB. Measure both TTFB and banner visibility.');
-    context.logger.info('Learn more: https://v2.c15t.com/docs/frameworks/nextjs/ssr');
+    context.logger.info('Learn more: https://c15t.com/docs/frameworks/nextjs/ssr');
     const enableSSR = await __rspack_external__clack_prompts_3cae1695.select({
         message: 'Enable SSR consent prefetch? (faster first banner visibility, dynamic route)',
         options: [
@@ -3668,7 +4198,7 @@ class ControlPlaneClient {
         const instances = await this.listInstances();
         const instance = instances.find((item)=>item.id === id);
         if (!instance) throw new CliError('INSTANCE_NOT_FOUND', {
-            details: `Instance not found: ${id}`
+            details: `Project not found: ${id}`
         });
         return instance;
     }
@@ -3762,8 +4292,8 @@ function createValidator(validate, errorMessage) {
     };
 }
 createValidator(isValidUrl, 'Please enter a valid URL (e.g., https://example.com)');
-createValidator(isValidC15tUrl, 'Please enter a valid c15t URL (e.g., https://my-app.c15t.dev)');
-const validateInstanceName = createValidator(isValidInstanceName, 'Instance name must be 3-63 lowercase alphanumeric characters with hyphens');
+createValidator(isValidC15tUrl, 'Please enter a valid hosted URL (e.g., https://my-app.inth.app)');
+const validateInstanceName = createValidator(isValidInstanceName, 'Project slug must be 3-63 lowercase alphanumeric characters with hyphens');
 createValidator((value)=>value.trim().length > 0, 'This field is required');
 function isCancel(value) {
     return __rspack_external__clack_prompts_3cae1695.isCancel(value);
@@ -3795,7 +4325,7 @@ const modeSelectionActor = fromPromise(async ({ input })=>{
             {
                 value: 'hosted',
                 label: 'Hosted',
-                hint: 'consent.io or self-hosted backend URL'
+                hint: 'inth.com or self-hosted backend URL'
             },
             {
                 value: 'offline',
@@ -3913,7 +4443,7 @@ async function createInstanceInteractively(client, cliContext) {
             })),
         initialValue: organizations[0]?.organizationSlug
     });
-    if (isCancel(orgSelection)) throw new PromptCancelledError('instance_create_org_slug');
+    if (isCancel(orgSelection)) throw new PromptCancelledError('project_create_org_slug');
     const v2Regions = regions.filter((region)=>'v2' === region.family);
     if (0 === v2Regions.length) throw new CliError('API_ERROR', {
         details: 'No v2 provisioning regions available'
@@ -3927,15 +4457,15 @@ async function createInstanceInteractively(client, cliContext) {
             })),
         initialValue: v2Regions.find((region)=>'us-east-1' === region.id)?.id
     });
-    if (isCancel(regionSelection)) throw new PromptCancelledError('instance_create_region');
+    if (isCancel(regionSelection)) throw new PromptCancelledError('project_create_region');
     const slugInput = await __rspack_external__clack_prompts_3cae1695.text({
-        message: 'New instance slug:',
+        message: 'New project slug:',
         placeholder: 'my-app',
         validate: (value)=>validateInstanceName(value?.trim() ?? '')
     });
-    if (isCancel(slugInput)) throw new PromptCancelledError('instance_create_name');
+    if (isCancel(slugInput)) throw new PromptCancelledError('project_create_name');
     const slug = slugInput.trim();
-    const createSpinner = createTaskSpinner(`Creating instance "${slug}"...`);
+    const createSpinner = createTaskSpinner(`Creating project "${slug}"...`);
     createSpinner.start();
     try {
         const instance = await client.createInstance({
@@ -3945,17 +4475,17 @@ async function createInstanceInteractively(client, cliContext) {
                 region: regionSelection
             }
         });
-        createSpinner.success('Instance created');
-        cliContext.logger.info('Created as a v2 development instance. Enable production mode in the dashboard when you are ready.');
+        createSpinner.success('Project created');
+        cliContext.logger.info('Created as a v2 development project. Enable production mode in the dashboard when you are ready.');
         return instance;
     } catch (error) {
-        createSpinner.error('Failed to create instance');
+        createSpinner.error('Failed to create project');
         throw error;
     }
 }
 async function selectOrCreateInstance(cliContext) {
     const baseUrl = getControlPlaneBaseUrl();
-    const listSpinner = createTaskSpinner('Fetching your consent.io instances...');
+    const listSpinner = createTaskSpinner('Fetching your inth.com projects...');
     listSpinner.start();
     const client = await createControlPlaneClientFromConfig(baseUrl);
     if (!client) {
@@ -3966,11 +4496,11 @@ async function selectOrCreateInstance(cliContext) {
         const instances = await client.listInstances();
         listSpinner.stop();
         if (0 === instances.length) {
-            cliContext.logger.info('No instances found. Creating a new instance for this project.');
+            cliContext.logger.info('No projects found. Creating a new project for this local project.');
             return await createInstanceInteractively(client, cliContext);
         }
         const selectedId = await __rspack_external__clack_prompts_3cae1695.select({
-            message: 'Select an instance to use:',
+            message: 'Select a project to use:',
             options: [
                 ...instances.map((instance)=>({
                         value: instance.id,
@@ -3979,12 +4509,12 @@ async function selectOrCreateInstance(cliContext) {
                     })),
                 {
                     value: '__create__',
-                    label: 'Create new instance',
-                    hint: 'Provision a new consent.io instance now'
+                    label: 'Create new project',
+                    hint: 'Provision a new inth.com project now'
                 }
             ]
         });
-        if (isCancel(selectedId)) throw new PromptCancelledError('instance_select');
+        if (isCancel(selectedId)) throw new PromptCancelledError('project_select');
         if ('__create__' === selectedId) return await createInstanceInteractively(client, cliContext);
         const selected = instances.find((instance)=>instance.id === selectedId);
         if (!selected) throw new CliError('INSTANCE_NOT_FOUND');
@@ -4004,8 +4534,8 @@ const hostedModeActor = fromPromise(async ({ input })=>{
             message: 'Choose your hosted backend option:',
             options: [
                 {
-                    value: 'consent.io',
-                    label: 'consent.io (Recommended)',
+                    value: 'inth.com',
+                    label: 'inth.com (Recommended)',
                     hint: 'Managed infrastucture'
                 },
                 {
@@ -4014,7 +4544,7 @@ const hostedModeActor = fromPromise(async ({ input })=>{
                     hint: 'Use your own deployed c15t backend'
                 }
             ],
-            initialValue: 'consent.io'
+            initialValue: 'inth.com'
         });
         if (isCancel(providerSelection)) throw new PromptCancelledError('hosted_provider');
         provider = providerSelection;
@@ -4032,29 +4562,28 @@ const hostedModeActor = fromPromise(async ({ input })=>{
         };
     }
     if (!isV2ModeEnabled()) {
-        cliContext.logger.info('consent.io sign-in is currently disabled. Set V2=1 to enable sign-in and instance selection.');
         const url = await promptBackendURL({
-            message: 'Enter your consent.io instance URL:',
-            placeholder: 'https://your-instance.c15t.dev',
+            message: 'Enter your inth.com project URL:',
+            placeholder: 'https://your-project.inth.app',
             initialURL,
             stage: 'consent_manual_url'
         });
         return {
             url,
-            provider: 'consent.io'
+            provider: 'inth.com'
         };
     }
     const setupMethod = await __rspack_external__clack_prompts_3cae1695.select({
-        message: 'How do you want to configure consent.io?',
+        message: 'How do you want to configure inth.com?',
         options: [
             {
                 value: 'sign-in',
-                label: 'Sign in and pick an instance',
-                hint: 'List existing instances or create a new one'
+                label: 'Sign in and pick a project',
+                hint: 'List existing projects or create a new one'
             },
             {
                 value: 'manual-url',
-                label: 'Enter instance URL manually',
+                label: 'Enter project URL manually',
                 hint: 'Use an existing backend URL'
             }
         ],
@@ -4063,23 +4592,23 @@ const hostedModeActor = fromPromise(async ({ input })=>{
     if (isCancel(setupMethod)) throw new PromptCancelledError('consent_setup_method');
     if ('manual-url' === setupMethod) {
         const url = await promptBackendURL({
-            message: 'Enter your consent.io instance URL:',
-            placeholder: 'https://your-instance.c15t.dev',
+            message: 'Enter your inth.com project URL:',
+            placeholder: 'https://your-project.inth.app',
             initialURL,
             stage: 'consent_manual_url'
         });
         return {
             url,
-            provider: 'consent.io'
+            provider: 'inth.com'
         };
     }
     await runConsentLogin(cliContext);
     const instance = await selectOrCreateInstance(cliContext);
     await setSelectedInstanceId(instance.id);
-    cliContext.logger.info(`Using instance ${picocolors.cyan(instance.name)} (${picocolors.dim(instance.id)})`);
+    cliContext.logger.info(`Using project ${picocolors.cyan(instance.name)} (${picocolors.dim(instance.id)})`);
     return {
         url: instance.url,
-        provider: 'consent.io'
+        provider: 'inth.com'
     };
 });
 const backendOptionsActor = fromPromise(async ({ input })=>{
@@ -4093,7 +4622,7 @@ const backendOptionsActor = fromPromise(async ({ input })=>{
     if ('@c15t/nextjs' === cliContext.framework.pkg) {
         cliContext.logger.info('Learn more about Next.js Rewrites: https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites');
         const proxyResult = await __rspack_external__clack_prompts_3cae1695.confirm({
-            message: 'Proxy requests to your instance with Next.js Rewrites? (Recommended)',
+            message: 'Proxy requests to your project with Next.js Rewrites? (Recommended)',
             initialValue: true
         });
         if (isCancel(proxyResult)) throw new PromptCancelledError('proxy_nextjs');
@@ -4130,7 +4659,7 @@ const frontendOptionsActor = fromPromise(async ({ input })=>{
             });
         }
         cliContext.logger.info('Choose how you want your consent UI components generated.');
-        cliContext.logger.info('Learn more: https://v2.c15t.com/docs/frameworks/nextjs/customization');
+        cliContext.logger.info('Learn more: https://c15t.com/docs/frameworks/nextjs/customization');
         const styleResult = await __rspack_external__clack_prompts_3cae1695.select({
             message: 'UI component style:',
             options: [
@@ -4536,7 +5065,7 @@ function normalizeSelectedMode(mode) {
 }
 function getHostedProviderFromMode(mode) {
     if ('self-hosted' === mode) return 'self-hosted';
-    if ('c15t' === mode) return 'consent.io';
+    if ('c15t' === mode) return 'inth.com';
     return null;
 }
 const generateMachine = setup({
@@ -4931,7 +5460,7 @@ const generateMachine = setup({
                 const { logger, packageManager } = context.cliContext;
                 if ('hosted' === context.selectedMode && 'self-hosted' === context.hostedProvider) {
                     logger.info('Setup your backend with the c15t docs:');
-                    logger.info('https://v2.c15t.com/docs/self-host/v2');
+                    logger.info('https://c15t.com/docs/self-host/v2');
                 } else if ('custom' === context.selectedMode) logger.info('Configuration Complete! Implement your custom endpoint handlers.');
                 if (context.installConfirmed && !context.installSucceeded) logger.warn('Dependency installation failed. Please check errors and install manually.');
                 else if (!context.installConfirmed && context.dependenciesToAdd.length > 0) {
@@ -5033,6 +5562,29 @@ const generateMachine = setup({
         }
     }
 });
+function getSetupTrigger(modeArg, resumed) {
+    if (resumed) return 'resume';
+    if (modeArg) return 'arg';
+    return 'interactive';
+}
+function normalizeSetupReason(finalState, finalContext) {
+    if ('complete' === finalState) return;
+    if ('preflightError' === finalState || !finalContext.preflightPassed && finalContext.preflightChecks.some((check)=>'fail' === check.status)) return 'preflight_failed';
+    if ('exited' === finalState || 'cancelled' === finalState) {
+        const reason = finalContext.cancelReason?.toLowerCase();
+        if (!reason) return 'user_cancelled';
+        if (reason.includes('signal')) return 'signal_interrupted';
+        if (reason.includes('mode selection')) return 'mode_selection_cancelled';
+        if (reason.includes('hosted setup')) return 'hosted_setup_cancelled';
+        if (reason.includes('backend options')) return 'backend_options_cancelled';
+        if (reason.includes('frontend options')) return 'frontend_options_cancelled';
+        if (reason.includes("scripts option")) return "scripts_options_cancelled";
+        return 'user_cancelled';
+    }
+    const lastError = finalContext.errors[finalContext.errors.length - 1];
+    if (lastError?.state) return `${lastError.state}_failed`;
+    return 'machine_error';
+}
 async function runGenerateMachine(options) {
     const { context: cliContext, modeArg, resume = false, debug = false, persist = true } = options;
     const { logger, telemetry } = cliContext;
@@ -5069,7 +5621,9 @@ async function runGenerateMachine(options) {
     const combinedSubscriber = combineSubscribers(...subscribers);
     actor.subscribe((snapshot)=>combinedSubscriber(snapshot));
     telemetry.trackEvent(TelemetryEventName.ONBOARDING_STARTED, {
-        resumed: resume && void 0 !== snapshot
+        resumed: resume && void 0 !== snapshot,
+        trigger: getSetupTrigger(modeArg, resume && void 0 !== snapshot),
+        requestedMode: modeArg ?? void 0
     });
     telemetry.flushSync();
     actor.start();
@@ -5085,11 +5639,28 @@ async function runGenerateMachine(options) {
                 const duration = Date.now() - startTime;
                 clearSnapshot(persistPath).catch(()=>{});
                 const success = 'complete' === finalState;
+                const durationMs = duration;
+                const reason = normalizeSetupReason(finalState, finalContext);
+                const result = success ? 'success' : 'exited' === finalState ? 'cancelled' : 'failed';
                 telemetry.trackEvent(TelemetryEventName.ONBOARDING_COMPLETED, {
                     success,
+                    result,
+                    reason,
+                    trigger: getSetupTrigger(modeArg, resume && void 0 !== snapshot),
+                    resumed: resume && void 0 !== snapshot,
                     selectedMode: finalContext.selectedMode ?? void 0,
+                    hostedProvider: finalContext.hostedProvider ?? void 0,
                     installDependencies: finalContext.installSucceeded,
+                    installConfirmed: finalContext.installConfirmed,
+                    installAttempted: finalContext.installAttempted,
+                    installSucceeded: finalContext.installSucceeded,
+                    dependencyCount: finalContext.dependenciesToAdd.length,
+                    filesCreatedCount: finalContext.filesCreated.length,
+                    filesModifiedCount: finalContext.filesModified.length,
+                    errorsCount: finalContext.errors.length,
+                    cancelReason: finalContext.cancelReason ?? void 0,
                     duration,
+                    durationMs,
                     finalState
                 });
                 resolve({
@@ -5139,6 +5710,294 @@ async function generate(context, mode) {
     ];
     return generateAction(context);
 }
+function instances_formatInstanceLabel(instance) {
+    if (instance.organizationSlug) return `${instance.organizationSlug}/${instance.name}`;
+    return instance.name;
+}
+function instances_formatInstanceRegion(instance) {
+    return `(${instance.region ?? 'unknown'})`;
+}
+async function requireAuth(context) {
+    if (!await isLoggedIn()) {
+        context.logger.error('You must be logged in to manage projects');
+        context.logger.message(`Run ${picocolors.cyan('c15t login')} to authenticate`);
+        throw new CliError('AUTH_NOT_LOGGED_IN');
+    }
+}
+async function listAction(context) {
+    const { logger, telemetry } = context;
+    const baseUrl = getControlPlaneBaseUrl();
+    await requireAuth(context);
+    const spinner = createTaskSpinner('Fetching projects...');
+    spinner.start();
+    try {
+        const client = await createControlPlaneClientFromConfig(baseUrl);
+        if (!client) {
+            spinner.stop();
+            throw new CliError('AUTH_NOT_LOGGED_IN');
+        }
+        const instances = await client.listInstances();
+        await client.close();
+        spinner.stop();
+        telemetry.trackEvent(TelemetryEventName.PROJECTS_LISTED, {
+            count: instances.length
+        });
+        if (0 === instances.length) {
+            logger.message('');
+            logger.message('No projects found.');
+            logger.message('');
+            logger.message(`Run ${picocolors.cyan('c15t projects create')} to create one`);
+            return;
+        }
+        const selectedId = await getSelectedInstanceId();
+        logger.message('');
+        logger.message(picocolors.bold('Your projects:'));
+        logger.message('');
+        for (const instance of instances){
+            const isSelected = instance.id === selectedId;
+            const status = getStatusColor(instance.status);
+            const marker = isSelected ? picocolors.green('▸ ') : '  ';
+            const label = instances_formatInstanceLabel(instance);
+            logger.message(`${marker}${picocolors.bold(label)} ${picocolors.dim(`(${instance.id})`)}`);
+            logger.message(`    Region: ${picocolors.cyan(instances_formatInstanceRegion(instance))}`);
+            logger.message(`    Status: ${status}`);
+            logger.message('');
+        }
+        if (selectedId) logger.message(picocolors.dim('▸ indicates the currently selected project'));
+    } catch (error) {
+        spinner.stop();
+        throw error;
+    }
+}
+async function selectAction(context) {
+    const { logger, telemetry, commandArgs } = context;
+    const baseUrl = getControlPlaneBaseUrl();
+    await requireAuth(context);
+    const spinner = createTaskSpinner('Fetching projects...');
+    spinner.start();
+    try {
+        const client = await createControlPlaneClientFromConfig(baseUrl);
+        if (!client) {
+            spinner.stop();
+            throw new CliError('AUTH_NOT_LOGGED_IN');
+        }
+        const instances = await client.listInstances();
+        await client.close();
+        spinner.stop();
+        if (0 === instances.length) {
+            logger.message('No projects found.');
+            logger.message(`Run ${picocolors.cyan('c15t projects create')} to create one`);
+            return;
+        }
+        let selectedInstance;
+        if (commandArgs.length > 0) {
+            const query = commandArgs[0];
+            const found = instances.find((i)=>i.id === query || i.name === query || instances_formatInstanceLabel(i) === query);
+            if (!found) throw new CliError('INSTANCE_NOT_FOUND', {
+                details: `No project found with ID, name, or org/name: ${query}`
+            });
+            selectedInstance = found;
+        } else {
+            const currentId = await getSelectedInstanceId();
+            const result = await __rspack_external__clack_prompts_3cae1695.select({
+                message: 'Select a project:',
+                options: instances.map((instance)=>({
+                        value: instance.id,
+                        label: instances_formatInstanceLabel(instance),
+                        hint: instance.id === currentId ? `(currently selected) • ${instances_formatInstanceRegion(instance)}` : instances_formatInstanceRegion(instance)
+                    }))
+            });
+            if (__rspack_external__clack_prompts_3cae1695.isCancel(result)) return void logger.info('Selection cancelled');
+            selectedInstance = instances.find((i)=>i.id === result);
+        }
+        await setSelectedInstanceId(selectedInstance.id);
+        telemetry.trackEvent(TelemetryEventName.PROJECT_SELECTED, {
+            projectId: selectedInstance.id
+        });
+        logger.success(`Selected project: ${picocolors.cyan(instances_formatInstanceLabel(selectedInstance))}`);
+        logger.message(`Region: ${instances_formatInstanceRegion(selectedInstance)}`);
+    } catch (error) {
+        spinner.stop();
+        throw error;
+    }
+}
+async function createAction(context) {
+    const { logger, telemetry, commandArgs } = context;
+    const baseUrl = getControlPlaneBaseUrl();
+    await requireAuth(context);
+    const client = await createControlPlaneClientFromConfig(baseUrl);
+    if (!client) throw new CliError('AUTH_NOT_LOGGED_IN');
+    try {
+        const preloadSpinner = createTaskSpinner('Loading organizations and regions...');
+        preloadSpinner.start();
+        let organizations;
+        let regions;
+        try {
+            [organizations, regions] = await Promise.all([
+                client.listOrganizations(),
+                client.listRegions()
+            ]);
+        } finally{
+            preloadSpinner.stop();
+        }
+        if (0 === organizations.length) throw new CliError('API_ERROR', {
+            details: 'No organizations available for this account'
+        });
+        if (0 === regions.length) throw new CliError('API_ERROR', {
+            details: 'No provisioning regions available'
+        });
+        let name;
+        if (commandArgs.length > 0) {
+            const providedName = commandArgs[0];
+            if (!providedName) throw new CliError('INSTANCE_NAME_INVALID', {
+                details: 'Project slug is required'
+            });
+            const error = validateInstanceName(providedName);
+            if (error) throw new CliError('INSTANCE_NAME_INVALID', {
+                details: error
+            });
+            name = providedName;
+        } else {
+            const result = await __rspack_external__clack_prompts_3cae1695.text({
+                message: 'Project slug:',
+                placeholder: 'my-app',
+                validate: (value)=>validateInstanceName(value?.trim() ?? '')
+            });
+            if (__rspack_external__clack_prompts_3cae1695.isCancel(result)) return void logger.info('Creation cancelled');
+            name = result;
+        }
+        name = name.trim();
+        const nameValidationError = validateInstanceName(name);
+        if (nameValidationError) throw new CliError('INSTANCE_NAME_INVALID', {
+            details: nameValidationError
+        });
+        const orgSelection = await __rspack_external__clack_prompts_3cae1695.select({
+            message: 'Select organization:',
+            options: organizations.map((org)=>({
+                    value: org.organizationSlug,
+                    label: org.organizationName,
+                    hint: `${org.organizationSlug} • ${org.role}`
+                })),
+            initialValue: organizations[0]?.organizationSlug
+        });
+        if (__rspack_external__clack_prompts_3cae1695.isCancel(orgSelection)) return void logger.info('Creation cancelled');
+        const v2Regions = regions.filter((region)=>'v2' === region.family);
+        if (0 === v2Regions.length) throw new CliError('API_ERROR', {
+            details: 'No v2 provisioning regions available'
+        });
+        const regionSelection = await __rspack_external__clack_prompts_3cae1695.select({
+            message: 'Select V2 region:',
+            options: v2Regions.map((region)=>({
+                    value: region.id,
+                    label: region.id,
+                    hint: region.label
+                })),
+            initialValue: v2Regions.find((region)=>'us-east-1' === region.id)?.id
+        });
+        if (__rspack_external__clack_prompts_3cae1695.isCancel(regionSelection)) return void logger.info('Creation cancelled');
+        const spinner = createTaskSpinner(`Creating project "${name}"...`);
+        spinner.start();
+        let instance;
+        try {
+            instance = await client.createInstance({
+                name,
+                config: {
+                    organizationSlug: orgSelection,
+                    region: regionSelection
+                }
+            });
+            spinner.success('Project created');
+        } catch (error) {
+            spinner.error('Failed to create project');
+            throw error;
+        }
+        telemetry.trackEvent(TelemetryEventName.PROJECT_CREATED, {
+            projectId: instance.id
+        });
+        logger.message('');
+        logger.message(`Name: ${picocolors.bold(instance.name)}`);
+        logger.message(`ID: ${picocolors.dim(instance.id)}`);
+        logger.message(`URL: ${picocolors.cyan(instance.url)}`);
+        logger.message('');
+        logger.info('Created as a v2 development project. Enable production mode in the dashboard when you are ready.');
+        const shouldSelect = await __rspack_external__clack_prompts_3cae1695.confirm({
+            message: 'Would you like to use this project for your project?',
+            initialValue: true
+        });
+        if (shouldSelect && !__rspack_external__clack_prompts_3cae1695.isCancel(shouldSelect)) {
+            await setSelectedInstanceId(instance.id);
+            logger.info('Project selected');
+        }
+    } finally{
+        await client.close();
+    }
+}
+function getStatusColor(status) {
+    switch(status){
+        case 'active':
+            return picocolors.green('active');
+        case 'inactive':
+            return picocolors.yellow('inactive');
+        case 'pending':
+            return picocolors.blue('pending');
+        default:
+            return status;
+    }
+}
+async function projectsAction(context) {
+    const { commandArgs } = context;
+    const subcommand = commandArgs[0];
+    switch(subcommand){
+        case 'list':
+            context.commandArgs = commandArgs.slice(1);
+            return listAction(context);
+        case 'select':
+            context.commandArgs = commandArgs.slice(1);
+            return selectAction(context);
+        case 'create':
+            context.commandArgs = commandArgs.slice(1);
+            return createAction(context);
+        default:
+            return listAction(context);
+    }
+}
+const projectsCommand = {
+    name: 'projects',
+    label: 'Projects',
+    hint: 'Manage your c15t projects',
+    description: 'List, select, and create c15t projects',
+    action: projectsAction,
+    subcommands: [
+        {
+            name: 'list',
+            label: 'List',
+            hint: 'List all projects',
+            description: 'List all c15t projects for your account',
+            action: listAction
+        },
+        {
+            name: 'select',
+            label: 'Select',
+            hint: 'Select a project',
+            description: 'Select a project for your local project',
+            action: selectAction
+        },
+        {
+            name: 'create',
+            label: 'Create',
+            hint: 'Create a new project',
+            description: 'Create a new c15t project',
+            action: createAction
+        }
+    ]
+};
+({
+    ...projectsCommand,
+    name: 'instances',
+    label: 'Instances',
+    description: 'Alias for `c15t projects`',
+    hidden: true
+});
 const validLogLevels = [
     'error',
     'warn',
@@ -5194,7 +6053,7 @@ const logger_logMessage = (logLevel, message, ...args)=>{
     }
 };
 const logger_createCliLogger = (level)=>{
-    const baseLogger = createLogger({
+    const baseLogger = logger_createLogger({
         level,
         appName: 'c15t',
         log: (logLevel, message, ...args)=>{
@@ -5205,23 +6064,26 @@ const logger_createCliLogger = (level)=>{
     extendedLogger.message = (message)=>{
         __rspack_external__clack_prompts_3cae1695.log.message(message);
     };
-    extendedLogger.note = (message, ...args)=>{
-        const messageStr = 'string' == typeof message ? message : String(message);
-        const title = args.length > 0 && 'string' == typeof args[0] ? args[0] : void 0;
-        __rspack_external__clack_prompts_3cae1695.note(messageStr, title, {
+    extendedLogger.note = (content, title)=>{
+        __rspack_external__clack_prompts_3cae1695.note(content, title, {
             format: (line)=>line
         });
     };
-    extendedLogger.success = (message, ...args)=>{
-        logger_logMessage('success', message, ...args);
+    extendedLogger.success = (message)=>{
+        logger_logMessage('success', message);
     };
-    extendedLogger.failed = (message, ...args)=>{
-        logger_logMessage('failed', message, ...args);
+    extendedLogger.failed = (message)=>{
+        logger_logMessage('failed', message);
         process.exit(0);
     };
     extendedLogger.outro = (message)=>{
         __rspack_external__clack_prompts_3cae1695.outro(message);
     };
+    extendedLogger.step = (current, total, label)=>{
+        const filled = picocolors.green('█'.repeat(current));
+        const empty = picocolors.dim('░'.repeat(total - current));
+        __rspack_external__clack_prompts_3cae1695.log.step(`[${filled}${empty}] Step ${current}/${total}: ${label}`);
+    };
     return extendedLogger;
 };
 async function addAndInstallDependenciesViaPM(projectRoot, dependencies, packageManager) {
@@ -6279,10 +7141,13 @@ async function createCliContext(rawArgs, cwd, commands) {
     const telemetryDisabled = true === parsedFlags['no-telemetry'];
     const telemetryDebug = true === parsedFlags['telemetry-debug'];
     try {
-        context.telemetry = createTelemetry({
+        context.telemetry = telemetry_createTelemetry({
             disabled: telemetryDisabled,
             debug: telemetryDebug,
             defaultProperties: {
+                entryCommand: commandName ?? 'interactive',
+                commandArgsCount: commandArgs.length,
+                enabledFlags: Object.entries(parsedFlags).filter(([, value])=>false !== value && void 0 !== value).map(([key])=>key).sort(),
                 cliVersion: context.fs.getPackageInfo().version,
                 framework: context.framework.framework ?? 'unknown',
                 frameworkVersion: context.framework.frameworkVersion ?? 'unknown',
@@ -6297,9 +7162,20 @@ async function createCliContext(rawArgs, cwd, commands) {
         if (telemetryDisabled) logger.debug('Telemetry is disabled by user preference');
         else if (telemetryDebug) logger.debug('Telemetry initialized with debug mode enabled');
         else logger.debug('Telemetry initialized');
+        context.telemetry.trackEvent(TelemetryEventName.CLI_ENVIRONMENT_DETECTED, {
+            command: commandName ?? 'interactive',
+            projectRootChanged: context.projectRoot !== cwd,
+            framework: context.framework.framework ?? 'unknown',
+            frameworkVersion: context.framework.frameworkVersion ?? 'unknown',
+            packageManager: context.packageManager.name,
+            packageManagerVersion: context.packageManager.version ?? 'unknown',
+            hasReact: context.framework.hasReact,
+            reactVersion: context.framework.reactVersion ?? 'unknown',
+            tailwindVersion: context.framework.tailwindVersion ?? 'unknown'
+        });
     } catch  {
         logger.warn('Failed to initialize telemetry, continuing with telemetry disabled');
-        context.telemetry = createTelemetry({
+        context.telemetry = telemetry_createTelemetry({
             disabled: true,
             logger: context.logger
         });
@@ -6363,6 +7239,21 @@ const src_commands = [
             await open_0(constants_URLS.GITHUB);
             logger.success('Thank you for your support!');
         }
+    },
+    {
+        name: 'projects',
+        label: 'Projects',
+        hint: 'Manage your c15t projects',
+        description: 'List, select, and create c15t projects.',
+        action: (context)=>projectsAction(context)
+    },
+    {
+        name: 'instances',
+        label: 'Instances',
+        hint: 'Alias for `projects`',
+        description: 'Alias for `c15t projects`.',
+        action: (context)=>projectsAction(context),
+        hidden: true
     }
 ];
 async function main() {
@@ -6438,7 +7329,7 @@ flag or set ${picocolors.cyan('C15T_TELEMETRY_DISABLED=1')} in your environment.
         } else {
             logger.debug('No command specified, entering interactive selection.');
             telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_OPENED, {});
-            const promptOptions = src_commands.map((cmd)=>({
+            const promptOptions = src_commands.filter((cmd)=>!cmd.hidden).map((cmd)=>({
                     value: cmd.name,
                     label: cmd.label,
                     hint: cmd.hint
@@ -6506,4 +7397,4 @@ flag or set ${picocolors.cyan('C15T_TELEMETRY_DISABLED=1')} in your environment.
     await telemetry.shutdown();
 }
 main();
-export { __webpack_require__temp as __webpack_require__, LAYOUT_PATTERNS, PAGES_APP_PATTERNS, STORAGE_MODES, config_store_getAccessToken as getAccessToken, constants_REGEX, getAuthState, logger_formatLogMessage, main, setSelectedInstanceId, storeTokens };
+export { __webpack_require__temp as __webpack_require__, LAYOUT_PATTERNS, PAGES_APP_PATTERNS, STORAGE_MODES, config_store_getAccessToken as getAccessToken, constants_REGEX, ensureGlobalCssStylesheetImports, formatSearchedCssPaths, getAuthState, getSelectedInstanceId, isLoggedIn, logger_formatLogMessage, main, setSelectedInstanceId, storeTokens };