@agentuity/cli 0.1.34 → 0.1.36

package/src/cmd/ai/index.ts

@@ -3,7 +3,6 @@ import cadenceCommand from './cadence';
 import capabilitiesCommand from './capabilities';
 import promptCommand from './prompt';
 import schemaCommand from './schema';
-import skillsCommand from './skills';
 import opencodeCommand from './opencode';
 import { getCommand } from '../../command-prefix';
 
@@ -25,10 +24,6 @@ export const command = createCommand({
 			command: getCommand('ai schema show'),
 			description: 'Output CLI schema for AI consumption',
 		},
-		{
-			command: getCommand('ai skills generate --output ./skills'),
-			description: 'Generate Agent Skills from CLI schema',
-		},
 	],
 	subcommands: [
 		opencodeCommand,
@@ -36,6 +31,5 @@ export const command = createCommand({
 		capabilitiesCommand,
 		promptCommand,
 		schemaCommand,
-		skillsCommand,
 	],
 });

package/src/cmd/ai/opencode/uninstall.ts

@@ -64,7 +64,7 @@ export const uninstallSubcommand = createSubcommand({
 				}
 			} catch (error) {
 				if (!jsonMode) {
-					tui.warn(`Failed to parse Open Code config: ${error}`);
+					tui.warning(`Failed to parse Open Code config: ${error}`);
 				}
 			}
 		}

package/src/cmd/build/vite/bun-dev-server.ts

@@ -15,6 +15,9 @@ export interface BunDevServerOptions {
 	deploymentId?: string;
 	logger: Logger;
 	vitePort: number; // Port of already-running Vite asset server
+	inspect?: boolean; // Enable bun debugger
+	inspectWait?: boolean; // Enable bun debugger and wait for connection
+	inspectBrk?: boolean; // Enable bun debugger with breakpoint at first line
 }
 
 export interface BunDevServerResult {
@@ -30,17 +33,15 @@ export interface BunDevServerResult {
  *
  * The bundle is loaded here to ensure AI Gateway routing patches are active.
  * Vite port is read from process.env.VITE_PORT at runtime.
+ *
+ * When debugger flags (inspect, inspectWait, inspectBrk) are passed, bun is spawned
+ * as a subprocess to enable passing the debugger CLI flags.
  */
 export async function startBunDevServer(options: BunDevServerOptions): Promise<BunDevServerResult> {
-	const { rootDir, port = 3500, logger, vitePort } = options;
+	const { rootDir, port = 3500, logger, vitePort, inspect, inspectWait, inspectBrk } = options;
 
 	logger.debug('Starting Bun dev server (Vite already running on port %d)...', vitePort);
 
-	// Load the bundled app - this will start Bun.serve() internally
-	// IMPORTANT: We must import the bundled .agentuity/app.js (NOT src/generated/app.ts)
-	// because the bundled version has LLM provider patches applied that enable AI Gateway routing.
-	// Importing the source file directly would bypass these patches.
-	logger.debug('📦 Loading bundled app (Bun server will start)...');
 	const appPath = `${rootDir}/.agentuity/app.js`;
 
 	// Verify bundle exists before attempting to load
@@ -54,29 +55,45 @@ export async function startBunDevServer(options: BunDevServerOptions): Promise<B
 	// Set PORT env var so the generated app uses the correct port
 	process.env.PORT = String(port);
 
-	// Import the generated app with cache-busting query parameter.
-	// Bun's module cache is keyed by the full specifier including query string,
-	// so adding a unique timestamp forces a fresh import on each reload.
-	const cacheBuster = `?t=${Date.now()}`;
-	try {
-		await import(appPath + cacheBuster);
-	} catch (err) {
-		const errorMessage = err instanceof Error ? err.message : String(err);
-		logger.error('Failed to import generated app from %s: %s', appPath, errorMessage);
-		throw new Error(`Failed to load generated app: ${errorMessage}`);
-	}
+	// Check if any debugger flag is enabled
+	const useDebugger = inspect || inspectWait || inspectBrk;
 
-	// Wait for server to actually start listening
-	// The generated app sets (globalThis as any).__AGENTUITY_SERVER__ when server starts
-	const maxRetries = 50; // Increased retries for slower systems
-	const retryDelay = 100; // ms
-	let serverReady = false;
+	if (useDebugger) {
+		// Spawn bun as subprocess with debugger flag
+		logger.debug('📦 Spawning bun with debugger enabled...');
+
+		// Determine which debugger flag to use (priority: inspectBrk > inspectWait > inspect)
+		let debugFlag: string;
+		if (inspectBrk) {
+			debugFlag = '--inspect-brk';
+		} else if (inspectWait) {
+			debugFlag = '--inspect-wait';
+		} else {
+			debugFlag = '--inspect';
+		}
 
-	for (let i = 0; i < maxRetries; i++) {
-		// Check if global server object exists
+		logger.debug('Using debugger flag: %s', debugFlag);
+
+		const bunProcess = Bun.spawn(['bun', debugFlag, 'run', appPath], {
+			cwd: rootDir,
+			stdout: 'inherit',
+			stderr: 'inherit',
+			env: {
+				...process.env,
+				PORT: String(port),
+			},
+		});
+
+		// Store the process globally so it can be killed on shutdown
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		if ((globalThis as any).__AGENTUITY_SERVER__) {
-			// Server object exists, now verify it's actually listening by making a request
+		(globalThis as any).__AGENTUITY_BUN_SUBPROCESS__ = bunProcess;
+
+		// Wait for server to actually start listening
+		const maxRetries = 50;
+		const retryDelay = 100;
+		let serverReady = false;
+
+		for (let i = 0; i < maxRetries; i++) {
 			try {
 				await fetch(`http://127.0.0.1:${port}/`, {
 					method: 'HEAD',
@@ -88,19 +105,79 @@ export async function startBunDevServer(options: BunDevServerOptions): Promise<B
 			} catch {
 				// Connection refused or timeout - server not ready yet
 			}
+			// Wait before next check
+			await new Promise((resolve) => setTimeout(resolve, retryDelay));
 		}
-		// Wait before next check
-		await new Promise((resolve) => setTimeout(resolve, retryDelay));
-	}
 
-	if (!serverReady) {
-		throw new Error(
-			`Bun server failed to start on port ${port} after ${maxRetries * retryDelay}ms`
-		);
-	}
+		if (!serverReady) {
+			// Kill the subprocess if server didn't start
+			try {
+				bunProcess.kill();
+			} catch (err) {
+				logger.debug('Error killing subprocess during startup failure: %s', err);
+			}
+			throw new Error(
+				`Bun server failed to start on port ${port} after ${maxRetries * retryDelay}ms`
+			);
+		}
+
+		logger.debug(`Bun dev server started on http://127.0.0.1:${port} with debugger enabled`);
+		logger.debug(`Asset requests (/@vite/*, /src/web/*, etc.) proxied to Vite:${vitePort}`);
+	} else {
+		// Load the bundled app - this will start Bun.serve() internally
+		// IMPORTANT: We must import the bundled .agentuity/app.js (NOT src/generated/app.ts)
+		// because the bundled version has LLM provider patches applied that enable AI Gateway routing.
+		// Importing the source file directly would bypass these patches.
+		logger.debug('📦 Loading bundled app (Bun server will start)...');
+
+		// Import the generated app with cache-busting query parameter.
+		// Bun's module cache is keyed by the full specifier including query string,
+		// so adding a unique timestamp forces a fresh import on each reload.
+		const cacheBuster = `?t=${Date.now()}`;
+		try {
+			await import(appPath + cacheBuster);
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			logger.error('Failed to import generated app from %s: %s', appPath, errorMessage);
+			throw new Error(`Failed to load generated app: ${errorMessage}`);
+		}
+
+		// Wait for server to actually start listening
+		// The generated app sets (globalThis as any).__AGENTUITY_SERVER__ when server starts
+		const maxRetries = 50; // Increased retries for slower systems
+		const retryDelay = 100; // ms
+		let serverReady = false;
 
-	logger.debug(`Bun dev server started on http://127.0.0.1:${port}`);
-	logger.debug(`Asset requests (/@vite/*, /src/web/*, etc.) proxied to Vite:${vitePort}`);
+		for (let i = 0; i < maxRetries; i++) {
+			// Check if global server object exists
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			if ((globalThis as any).__AGENTUITY_SERVER__) {
+				// Server object exists, now verify it's actually listening by making a request
+				try {
+					await fetch(`http://127.0.0.1:${port}/`, {
+						method: 'HEAD',
+						signal: AbortSignal.timeout(1000),
+					});
+					// Any response (even 404) means server is listening
+					serverReady = true;
+					break;
+				} catch {
+					// Connection refused or timeout - server not ready yet
+				}
+			}
+			// Wait before next check
+			await new Promise((resolve) => setTimeout(resolve, retryDelay));
+		}
+
+		if (!serverReady) {
+			throw new Error(
+				`Bun server failed to start on port ${port} after ${maxRetries * retryDelay}ms`
+			);
+		}
+
+		logger.debug(`Bun dev server started on http://127.0.0.1:${port}`);
+		logger.debug(`Asset requests (/@vite/*, /src/web/*, etc.) proxied to Vite:${vitePort}`);
+	}
 
 	return {
 		bunServerPort: port,

package/src/cmd/cloud/apikey/create.ts

@@ -95,7 +95,9 @@ export const createSubcommand = createSubcommandHelper({
 			tui.newline();
 			tui.success('API key created successfully!');
 			tui.newline();
-			tui.warn('Make sure to copy the API key value now. You will not be able to see it again.');
+			tui.warning(
+				'Make sure to copy the API key value now. You will not be able to see it again.'
+			);
 			tui.newline();
 
 			const rows = [

package/src/cmd/cloud/deploy.ts

@@ -168,7 +168,10 @@ export const deploySubcommand = createSubcommand({
 		const hasTTY = process.stdin.isTTY && process.stdout.isTTY;
 		if (project.region) {
 			try {
-				const serverProject = await projectGet(apiClient, { id: project.projectId, keys: false });
+				const serverProject = await projectGet(apiClient, {
+					id: project.projectId,
+					keys: false,
+				});
 				const serverRegion = serverProject.cloudRegion;
 
 				if (serverRegion && serverRegion !== project.region) {

package/src/cmd/cloud/env/delete.ts

@@ -14,24 +14,30 @@ import { resolveOrgId, isOrgScope } from './org-util';
 
 const EnvDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
-	key: z.string().describe('Variable key that was deleted'),
+	keys: z.array(z.string()).describe('Variable keys that were deleted'),
 	path: z
 		.string()
 		.optional()
-		.describe('Local file path where variable was removed (project scope only)'),
-	secret: z.boolean().describe('Whether a secret was deleted'),
-	scope: z.enum(['project', 'org']).describe('The scope from which the variable was deleted'),
+		.describe('Local file path where variables were removed (project scope only)'),
+	secrets: z.array(z.string()).describe('Keys that were secrets'),
+	env: z.array(z.string()).describe('Keys that were environment variables'),
+	scope: z.enum(['project', 'org']).describe('The scope from which the variables were deleted'),
+	notFound: z.array(z.string()).optional().describe('Keys that were not found'),
 });
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	aliases: ['del', 'remove', 'rm'],
-	description: 'Delete an environment variable or secret',
+	description: 'Delete one or more environment variables or secrets',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	idempotent: true,
 	examples: [
-		{ command: getCommand('env delete OLD_FEATURE_FLAG'), description: 'Delete variable' },
+		{ command: getCommand('env delete OLD_FEATURE_FLAG'), description: 'Delete a variable' },
 		{ command: getCommand('env rm API_KEY'), description: 'Delete a secret' },
+		{
+			command: getCommand('env rm KEY1 KEY2 KEY3'),
+			description: 'Delete multiple variables at once',
+		},
 		{
 			command: getCommand('env rm OPENAI_API_KEY --org'),
 			description: 'Delete org-level secret',
@@ -41,7 +47,7 @@ export const deleteSubcommand = createSubcommand({
 	optional: { project: true },
 	schema: {
 		args: z.object({
-			key: z.string().describe('the variable or secret key to delete'),
+			key: z.array(z.string()).describe('the variable or secret key(s) to delete'),
 		}),
 		options: z.object({
 			org: z
@@ -57,6 +63,7 @@ export const deleteSubcommand = createSubcommand({
 	async handler(ctx) {
 		const { args, project, projectDir, apiClient, config, opts } = ctx;
 		const useOrgScope = isOrgScope(opts?.org);
+		const keys = args.key;
 
 		// Require project context if not using org scope
 		if (!useOrgScope && !project) {
@@ -65,10 +72,11 @@ export const deleteSubcommand = createSubcommand({
 			);
 		}
 
-		// Validate key doesn't start with reserved AGENTUITY_ prefix (except AGENTUITY_PUBLIC_)
-		if (isReservedAgentuityKey(args.key)) {
+		// Validate no keys start with reserved AGENTUITY_ prefix (except AGENTUITY_PUBLIC_)
+		const reservedKeys = keys.filter(isReservedAgentuityKey);
+		if (reservedKeys.length > 0) {
 			tui.fatal(
-				'Cannot delete AGENTUITY_ prefixed variables. These are reserved for system use.'
+				`Cannot delete AGENTUITY_ prefixed variables: ${reservedKeys.join(', ')}. These are reserved for system use.`
 			);
 		}
 
@@ -76,85 +84,132 @@ export const deleteSubcommand = createSubcommand({
 			// Organization scope
 			const orgId = await resolveOrgId(apiClient, config, opts!.org!);
 
-			// First, determine if this key exists in env or secrets
-			const orgData = await tui.spinner('Checking organization variable', () => {
+			// First, determine which keys exist in env or secrets
+			const orgData = await tui.spinner('Checking organization variables', () => {
 				return orgEnvGet(apiClient, { id: orgId, mask: true });
 			});
 
-			const isSecret = orgData.secrets?.[args.key] !== undefined;
-			const isEnv = orgData.env?.[args.key] !== undefined;
+			const secretKeys: string[] = [];
+			const envKeys: string[] = [];
+			const notFoundKeys: string[] = [];
+
+			for (const key of keys) {
+				if (orgData.secrets?.[key] !== undefined) {
+					secretKeys.push(key);
+				} else if (orgData.env?.[key] !== undefined) {
+					envKeys.push(key);
+				} else {
+					notFoundKeys.push(key);
+				}
+			}
 
-			if (!isSecret && !isEnv) {
+			// If all keys are not found, fail
+			if (secretKeys.length === 0 && envKeys.length === 0) {
 				tui.fatal(
-					`Variable '${args.key}' not found in organization`,
+					`No variables found in organization: ${keys.join(', ')}`,
 					ErrorCode.RESOURCE_NOT_FOUND
 				);
 			}
 
-			// Delete from cloud
-			const label = isSecret ? 'secret' : 'environment variable';
-			await tui.spinner(`Deleting organization ${label} from cloud`, () => {
+			// Delete from cloud (batch operation)
+			const totalToDelete = secretKeys.length + envKeys.length;
+			const label = totalToDelete === 1 ? 'variable' : 'variables';
+			await tui.spinner(`Deleting ${totalToDelete} organization ${label} from cloud`, () => {
 				return orgEnvDelete(apiClient, {
 					id: orgId,
-					...(isSecret ? { secrets: [args.key] } : { env: [args.key] }),
+					...(secretKeys.length > 0 ? { secrets: secretKeys } : {}),
+					...(envKeys.length > 0 ? { env: envKeys } : {}),
 				});
 			});
 
+			const deletedKeys = [...secretKeys, ...envKeys];
+			if (notFoundKeys.length > 0) {
+				tui.warning(`Variables not found (skipped): ${notFoundKeys.join(', ')}`);
+			}
 			tui.success(
-				`Organization ${isSecret ? 'secret' : 'environment variable'} '${args.key}' deleted successfully`
+				`Deleted ${deletedKeys.length} organization variable(s): ${deletedKeys.join(', ')}`
 			);
 
 			return {
 				success: true,
-				key: args.key,
-				secret: isSecret,
+				keys: deletedKeys,
+				secrets: secretKeys,
+				env: envKeys,
 				scope: 'org' as const,
+				...(notFoundKeys.length > 0 ? { notFound: notFoundKeys } : {}),
 			};
 		} else {
-			// Project scope (existing behavior)
-			const projectData = await tui.spinner('Checking variable', () => {
+			// Project scope
+			const projectData = await tui.spinner('Checking variables', () => {
 				return projectGet(apiClient, { id: project!.projectId, mask: true });
 			});
 
-			const isSecret = projectData.secrets?.[args.key] !== undefined;
-			const isEnv = projectData.env?.[args.key] !== undefined;
+			const secretKeys: string[] = [];
+			const envKeys: string[] = [];
+			const notFoundKeys: string[] = [];
+
+			for (const key of keys) {
+				if (projectData.secrets?.[key] !== undefined) {
+					secretKeys.push(key);
+				} else if (projectData.env?.[key] !== undefined) {
+					envKeys.push(key);
+				} else {
+					notFoundKeys.push(key);
+				}
+			}
 
-			if (!isSecret && !isEnv) {
-				tui.fatal(`Variable '${args.key}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			// If all keys are not found, fail
+			if (secretKeys.length === 0 && envKeys.length === 0) {
+				tui.fatal(`No variables found: ${keys.join(', ')}`, ErrorCode.RESOURCE_NOT_FOUND);
 			}
 
-			// Delete from cloud using the correct field
-			const label = isSecret ? 'secret' : 'environment variable';
-			await tui.spinner(`Deleting ${label} from cloud`, () => {
+			// Delete from cloud (batch operation)
+			const totalToDelete = secretKeys.length + envKeys.length;
+			const label = totalToDelete === 1 ? 'variable' : 'variables';
+			await tui.spinner(`Deleting ${totalToDelete} ${label} from cloud`, () => {
 				return projectEnvDelete(apiClient, {
 					id: project!.projectId,
-					...(isSecret ? { secrets: [args.key] } : { env: [args.key] }),
+					...(secretKeys.length > 0 ? { secrets: secretKeys } : {}),
+					...(envKeys.length > 0 ? { env: envKeys } : {}),
 				});
 			});
 
-			// Update local .env file only if we have a project directory
-			// (not when using --project-id without being in a project folder)
+			// Update local .env file only if we have a project directory and an existing .env file
 			let envFilePath: string | undefined;
 			if (projectDir) {
 				envFilePath = await findExistingEnvFile(projectDir);
-				const currentEnv = await readEnvFile(envFilePath);
-				delete currentEnv[args.key];
+				if (envFilePath) {
+					const currentEnv = await readEnvFile(envFilePath);
+					const originalKeyCount = Object.keys(currentEnv).length;
+					for (const key of [...secretKeys, ...envKeys]) {
+						delete currentEnv[key];
+					}
+					// Only write if we actually removed keys (avoid creating empty file)
+					const keysRemoved = originalKeyCount > Object.keys(currentEnv).length;
+					if (keysRemoved) {
+						await writeEnvFile(envFilePath, currentEnv, { preserveExisting: false });
+					}
+				}
+			}
 
-				// Write the updated env, preserveExisting: false since we already have the full state
-				await writeEnvFile(envFilePath, currentEnv, { preserveExisting: false });
+			const deletedKeys = [...secretKeys, ...envKeys];
+			if (notFoundKeys.length > 0) {
+				tui.warning(`Variables not found (skipped): ${notFoundKeys.join(', ')}`);
 			}
 
-			const successMsg = envFilePath
-				? `${isSecret ? 'Secret' : 'Environment variable'} '${args.key}' deleted successfully (cloud + ${envFilePath})`
-				: `${isSecret ? 'Secret' : 'Environment variable'} '${args.key}' deleted successfully (cloud only)`;
-			tui.success(successMsg);
+			const locationMsg = envFilePath ? ` (cloud + ${envFilePath})` : ' (cloud only)';
+			tui.success(
+				`Deleted ${deletedKeys.length} variable(s): ${deletedKeys.join(', ')}${locationMsg}`
+			);
 
 			return {
 				success: true,
-				key: args.key,
+				keys: deletedKeys,
 				path: envFilePath,
-				secret: isSecret,
+				secrets: secretKeys,
+				env: envKeys,
 				scope: 'project' as const,
+				...(notFoundKeys.length > 0 ? { notFound: notFoundKeys } : {}),
 			};
 		}
 	},

package/src/cmd/cloud/env/pull.ts

@@ -2,12 +2,7 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectGet, orgEnvGet } from '@agentuity/server';
-import {
-	findExistingEnvFile,
-	readEnvFile,
-	writeEnvFile,
-	mergeEnvVars,
-} from '../../../env-util';
+import { findExistingEnvFile, readEnvFile, writeEnvFile, mergeEnvVars } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 import { resolveOrgId, isOrgScope } from './org-util';
 

package/src/cmd/cloud/machine/delete.ts

@@ -49,7 +49,7 @@ export const deleteSubcommand = createSubcommand({
 			if (!opts.confirm) {
 				if (process.stdin.isTTY) {
 					tui.newline();
-					tui.warn(`You are about to delete machine ${tui.bold(machine.id)}`);
+					tui.warning(`You are about to delete machine ${tui.bold(machine.id)}`);
 					if (machine.orgName) {
 						tui.info(`Organization: ${machine.orgName}`);
 					}

package/src/cmd/dev/index.ts

@@ -18,7 +18,6 @@ import { typecheck } from '../build/typecheck';
 import { validateGravityRequiresUpgrade } from '../../runtime';
 import { isTTY, hasLoggedInBefore } from '../../auth';
 import { createFileWatcher } from './file-watcher';
-import { regenerateSkillsAsync } from './skills';
 import { prepareDevLock, releaseLockSync } from './dev-lock';
 import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
 import { ErrorCode } from '../../errors';
@@ -81,6 +80,7 @@ async function killLingeringGravityProcesses(logger: {
 /**
  * Stop the existing Bun server if one is running.
  * Waits for the port to become available before returning (with timeout).
+ * Handles both in-process server and subprocess (when debugger is enabled).
  */
 async function stopBunServer(
 	port: number,
@@ -88,6 +88,48 @@ async function stopBunServer(
 ): Promise<void> {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const globalAny = globalThis as any;
+
+	// Check for subprocess first (used when debugger flags are enabled)
+	const bunSubprocess = globalAny.__AGENTUITY_BUN_SUBPROCESS__ as ProcessLike | undefined;
+	if (bunSubprocess) {
+		logger.debug('Stopping Bun subprocess...');
+		try {
+			bunSubprocess.kill('SIGTERM');
+			// After SIGTERM, wait and check multiple times before giving up
+			let attempts = 0;
+			while (bunSubprocess.exitCode === null && attempts < 3) {
+				await new Promise((resolve) => setTimeout(resolve, 100));
+				attempts++;
+			}
+			if (bunSubprocess.exitCode === null) {
+				bunSubprocess.kill('SIGKILL');
+			}
+			logger.debug('Bun subprocess killed');
+		} catch (err) {
+			logger.debug('Error killing Bun subprocess: %s', err);
+		}
+		globalAny.__AGENTUITY_BUN_SUBPROCESS__ = undefined;
+
+		// Wait for port to become available
+		const MAX_WAIT_ITERATIONS = 10;
+		for (let i = 0; i < MAX_WAIT_ITERATIONS; i++) {
+			try {
+				await fetch(`http://127.0.0.1:${port}/`, {
+					method: 'HEAD',
+					signal: AbortSignal.timeout(150),
+				});
+				// Still responding, wait a bit more
+				await new Promise((r) => setTimeout(r, 50));
+			} catch {
+				// Connection refused or timeout => server is down
+				logger.debug('Bun subprocess stopped');
+				break;
+			}
+		}
+		return;
+	}
+
+	// Handle in-process server
 	const server = globalAny.__AGENTUITY_SERVER__ as BunServer | undefined;
 	if (!server) {
 		logger.debug('No Bun server to stop');
@@ -171,6 +213,15 @@ export const command = createCommand({
 				.max(MAX_PORT)
 				.default(getDefaultPort())
 				.describe('The TCP port to start the dev server (also reads from PORT env)'),
+			inspect: z.boolean().optional().describe('Enable bun debugger on available port'),
+			inspectWait: z
+				.boolean()
+				.optional()
+				.describe('Enable bun debugger and wait for connection before executing'),
+			inspectBrk: z
+				.boolean()
+				.optional()
+				.describe('Enable bun debugger with breakpoint at first line'),
 		}),
 	},
 	optional: { project: true },
@@ -489,12 +540,6 @@ export const command = createCommand({
 				centerTitle: false,
 			});
 
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const cliVersion = ((global as any).__CLI_SCHEMA__?.version as string) ?? '';
-			if (cliVersion) {
-				regenerateSkillsAsync(rootDir, cliVersion, logger).catch(() => {});
-			}
-
 			// Start Vite asset server ONCE before restart loop
 			// Vite handles frontend HMR independently and stays running across backend restarts
 			let viteServer: ServerLike | null = null;
@@ -961,7 +1006,7 @@ export const command = createCommand({
 					}
 				} catch (error) {
 					tui.error(`Failed to build dev bundle: ${error}`);
-					tui.warn('Waiting for file changes to retry...');
+					tui.warning('Waiting for file changes to retry...');
 
 					// Resume watcher to detect changes for retry
 					fileWatcher.resume();
@@ -986,7 +1031,7 @@ export const command = createCommand({
 						if (sdkKey) {
 							process.env.AGENTUITY_SDK_KEY = sdkKey;
 						} else if (project) {
-							tui.warn(
+							tui.warning(
 								'AGENTUITY_SDK_KEY not found in .env file. Numerous features will be unavailable.'
 							);
 							tui.bullet(
@@ -1035,6 +1080,9 @@ export const command = createCommand({
 						deploymentId,
 						logger,
 						vitePort, // Pass port of already-running Vite server
+						inspect: opts.inspect,
+						inspectWait: opts.inspectWait,
+						inspectBrk: opts.inspectBrk,
 					});
 
 					// Wait for app.ts to finish loading (Vite is ready but app may still be initializing)
@@ -1047,7 +1095,7 @@ export const command = createCommand({
 					}
 				} catch (error) {
 					tui.error(`Failed to start dev server: ${error}`);
-					tui.warn('Waiting for file changes to retry...');
+					tui.warning('Waiting for file changes to retry...');
 
 					// Wait for next restart trigger or shutdown
 					await new Promise<void>((resolve) => {
@@ -1274,7 +1322,7 @@ export const command = createCommand({
 					await Bun.sleep(500);
 				} catch (error) {
 					tui.error(`Error during server operation: ${error}`);
-					tui.warn('Waiting for file changes to retry...');
+					tui.warning('Waiting for file changes to retry...');
 
 					// Cleanup on error (Vite stays running)
 					await cleanupForRestart();

package/src/cmd/index.ts

@@ -15,6 +15,7 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 		import('./project').then((m) => m.command),
 		import('./repl').then((m) => m.command),
 		import('./setup').then((m) => m.command),
+		import('./support').then((m) => m.command),
 		import('./upgrade').then((m) => m.command),
 		import('./version').then((m) => m.command),
 	]);