@agentuity/cli 2.0.13 → 2.0.15

package/src/cmd/cloud/aigateway/models.ts

@@ -0,0 +1,219 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { getExecutingAgent } from '../../../agent-detection';
+import { createPublicAIGatewayService, getAIGatewayUrl } from './util';
+import { getCachedAIGatewayModels, setCachedAIGatewayModels } from './model-cache';
+
+const ModelRowSchema = z.object({
+	provider: z.string(),
+	id: z.string(),
+	name: z.string(),
+	api: z.string().optional(),
+	reasoning: z.boolean().optional(),
+	contextWindow: z.number().optional(),
+	maxOutputTokens: z.number().optional(),
+});
+
+const ModelsResponseSchema = z.object({
+	models: z.array(ModelRowSchema),
+	count: z.number(),
+	model: ModelRowSchema.nullable().optional(),
+});
+
+const recommendedModels = [
+	{ use: 'fast', candidates: ['openai/gpt-4o-mini', 'openai/gpt-4.1-mini'] },
+	{ use: 'reasoning', candidates: ['openai/gpt-5-mini', 'openai/o4-mini'] },
+	{ use: 'coding', candidates: ['anthropic/claude-opus-4-7', 'openai/gpt-5-codex'] },
+	{ use: 'cheap', candidates: ['openai/gpt-4.1-nano', 'openai/gpt-5-nano'] },
+];
+
+function isAgentOutputMode(): boolean {
+	return Boolean(getExecutingAgent()) && process.env.AGENTUITY_AIGATEWAY_AGENT_OUTPUT !== 'false';
+}
+
+function getRecommendations(rows: z.infer<typeof ModelRowSchema>[]) {
+	const byId = new Map(rows.map((row) => [normalizeModelId(row.id), row]));
+	return recommendedModels
+		.map((rec) => {
+			const model = rec.candidates.map((id) => byId.get(normalizeModelId(id))).find(Boolean);
+			return model ? { use: rec.use, model: model.id, name: model.name } : undefined;
+		})
+		.filter((row): row is { use: string; model: string; name: string } => Boolean(row));
+}
+
+function normalizeModelId(id: string): string {
+	const normalized = id.toLowerCase();
+	const parts = normalized.split('/');
+	return parts.length > 1 ? (parts.at(-1) ?? normalized) : normalized;
+}
+
+function matchesProviderFilter(
+	provider: string,
+	modelId: string,
+	providerFilter?: string
+): boolean {
+	if (!providerFilter) {
+		return true;
+	}
+	return provider === providerFilter || modelId.startsWith(`${providerFilter}/`);
+}
+
+function matchesModelFilter(provider: string, modelId: string, modelFilter?: string): boolean {
+	if (!modelFilter) {
+		return true;
+	}
+	return modelId === modelFilter || `${provider}/${modelId}` === modelFilter;
+}
+
+function matchesNameFilter(modelId: string, modelName: string, nameFilter?: string): boolean {
+	if (!nameFilter) {
+		return true;
+	}
+	const normalized = nameFilter.toLowerCase();
+	return (
+		modelId.toLowerCase() === normalized ||
+		modelId.split('/').pop()?.toLowerCase() === normalized ||
+		modelName.toLowerCase() === normalized
+	);
+}
+
+export const modelsSubcommand = createCommand({
+	name: 'models',
+	aliases: ['list', 'ls'],
+	description: 'List AI Gateway models',
+	tags: ['read-only', 'fast'],
+	idempotent: true,
+	examples: [
+		{ command: getCommand('cloud aigateway models'), description: 'List all models' },
+		{
+			command: getCommand('cloud aigateway models --provider openai'),
+			description: 'List OpenAI models',
+		},
+		{
+			command: getCommand('cloud aigateway models --model anthropic/claude-opus-4-7'),
+			description: 'Show one model by id',
+		},
+	],
+	schema: {
+		options: z.object({
+			model: z.string().optional().describe('show one model by full provider/id'),
+			provider: z.string().optional().describe('filter by provider'),
+			name: z
+				.string()
+				.optional()
+				.describe('show one model by id or display name with --provider'),
+			reasoning: z.boolean().optional().describe('only show reasoning models'),
+			input: z.string().optional().describe('filter by input modality, such as text or image'),
+			output: z.string().optional().describe('filter by output modality, such as text or image'),
+			ids: z.boolean().optional().describe('only print model ids'),
+			simple: z.boolean().optional().describe('print a compact model list'),
+			recommended: z.boolean().optional().describe('show recommended models for common uses'),
+			refreshModels: z
+				.boolean()
+				.optional()
+				.describe('refresh the cached AI Gateway model catalog'),
+		}),
+		response: ModelsResponseSchema,
+	},
+	async handler(ctx) {
+		const service = createPublicAIGatewayService(ctx);
+		const profile = ctx.config?.name ?? 'default';
+		const cacheKey = getAIGatewayUrl(ctx.region, ctx.config?.overrides);
+		const cached = ctx.opts.refreshModels
+			? null
+			: await getCachedAIGatewayModels(profile, cacheKey);
+		const catalog = cached ?? (await service.listModels());
+		if (!cached) {
+			await setCachedAIGatewayModels(profile, cacheKey, catalog);
+		}
+		const rows = Object.entries(catalog).flatMap(([provider, models]) =>
+			models
+				.filter((model) => matchesProviderFilter(provider, model.id, ctx.opts.provider))
+				.filter((model) => matchesModelFilter(provider, model.id, ctx.opts.model))
+				.filter((model) => matchesNameFilter(model.id, model.name, ctx.opts.name))
+				.filter((model) => !ctx.opts.reasoning || model.reasoning)
+				.filter((model) => !ctx.opts.input || model.input_modalities?.includes(ctx.opts.input))
+				.filter(
+					(model) => !ctx.opts.output || model.output_modalities?.includes(ctx.opts.output)
+				)
+				.map((model) => ({
+					provider,
+					id: model.id,
+					name: model.name,
+					api: model.api,
+					reasoning: model.reasoning,
+					contextWindow: model.context_window,
+					maxOutputTokens: model.max_output_tokens,
+				}))
+		);
+		const singleLookup = Boolean(ctx.opts.model || ctx.opts.name);
+		const selectedModel = singleLookup ? (rows[0] ?? null) : undefined;
+
+		const agentOutput = isAgentOutputMode();
+		if (ctx.options.json || agentOutput) {
+			if (agentOutput && !ctx.options.json) {
+				if (ctx.opts.ids) {
+					console.log(
+						JSON.stringify({ ids: rows.map((row) => row.id), count: rows.length }, null, 2)
+					);
+				} else if (ctx.opts.recommended) {
+					console.log(JSON.stringify({ recommendations: getRecommendations(rows) }, null, 2));
+				} else if (singleLookup) {
+					console.log(
+						JSON.stringify(
+							{ model: selectedModel, models: rows, count: rows.length },
+							null,
+							2
+						)
+					);
+				} else {
+					console.log(JSON.stringify({ models: rows, count: rows.length }, null, 2));
+				}
+			}
+		} else {
+			if (rows.length === 0) {
+				tui.info('No AI Gateway models found');
+			} else if (ctx.opts.ids) {
+				for (const row of rows) {
+					console.log(row.id);
+				}
+			} else if (ctx.opts.recommended) {
+				const recommendations = getRecommendations(rows).map((row) => ({
+					Use: row.use,
+					Model: row.model,
+					Name: row.name,
+				}));
+				if (recommendations.length === 0) {
+					tui.info('No recommended AI Gateway models found');
+				} else {
+					tui.table(recommendations, ['Use', 'Model', 'Name']);
+				}
+			} else if (ctx.opts.simple) {
+				tui.table(
+					rows.map((row) => ({
+						Model: row.id,
+						Name: row.name,
+					})),
+					['Model', 'Name']
+				);
+			} else {
+				tui.info(`Found ${rows.length} AI Gateway model(s):`);
+				tui.table(
+					rows.map((row) => ({
+						Provider: row.provider,
+						Model: row.id,
+						Name: row.name,
+						API: row.api ?? '-',
+						Reasoning: row.reasoning ? 'yes' : 'no',
+						Context: row.contextWindow ?? '-',
+					})),
+					['Provider', 'Model', 'Name', 'API', 'Reasoning', 'Context']
+				);
+			}
+		}
+
+		return { models: rows, count: rows.length, model: selectedModel };
+	},
+});

package/src/cmd/cloud/aigateway/util.ts

@@ -0,0 +1,86 @@
+import { AIGatewayService, type Logger } from '@agentuity/core';
+import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
+import * as tui from '../../../tui';
+import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
+
+const defaultAIGatewayRegion = 'usc';
+
+export function getAIGatewayUrl(
+	region?: string,
+	overrides?: { aigateway_url?: string } | null
+): string {
+	if (process.env.AGENTUITY_AIGATEWAY_URL) {
+		return process.env.AGENTUITY_AIGATEWAY_URL;
+	}
+	if (overrides?.aigateway_url) {
+		return overrides.aigateway_url;
+	}
+	return getServiceUrls(region || process.env.AGENTUITY_REGION || defaultAIGatewayRegion)
+		.aigateway;
+}
+
+export function createAIGatewayService(ctx: {
+	logger: Logger;
+	auth: AuthData;
+	region?: string;
+	project?: ProjectConfig;
+	config: Config | null;
+	options: GlobalOptions;
+}) {
+	const orgId =
+		ctx.project?.orgId ??
+		ctx.options.orgId ??
+		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+	if (!orgId) {
+		tui.fatal(
+			'Organization ID is required. Either run from a project directory or use --org-id flag.'
+		);
+	}
+
+	const adapter = createServerFetchAdapter(
+		{
+			headers: {
+				Authorization: `Bearer ${ctx.auth.apiKey}`,
+				'x-agentuity-orgid': orgId,
+			},
+		},
+		ctx.logger
+	);
+
+	return new AIGatewayService(getAIGatewayUrl(ctx.region, ctx.config?.overrides), adapter);
+}
+
+export function createPublicAIGatewayService(ctx: {
+	logger: Logger;
+	region?: string;
+	config: Config | null;
+}) {
+	const adapter = createServerFetchAdapter({ headers: {} }, ctx.logger);
+	return new AIGatewayService(getAIGatewayUrl(ctx.region, ctx.config?.overrides), adapter);
+}
+
+export function getCompletionText(response: unknown): string {
+	const choices = (response as { choices?: unknown }).choices;
+	const first =
+		Array.isArray(choices) && choices.length > 0
+			? (choices[0] as { message?: { content?: unknown }; text?: unknown; delta?: unknown })
+			: undefined;
+	const content =
+		first?.message?.content ?? first?.text ?? (response as { content?: unknown }).content;
+	if (typeof content === 'string') {
+		return content;
+	}
+	if (Array.isArray(content)) {
+		return content
+			.map((part) => {
+				if (typeof part === 'string') return part;
+				if (part && typeof part === 'object' && 'text' in part) {
+					const text = (part as { text?: unknown }).text;
+					return typeof text === 'string' ? text : '';
+				}
+				return '';
+			})
+			.join('');
+	}
+	return '';
+}

package/src/cmd/cloud/index.ts

@@ -14,6 +14,7 @@ import webhookCommand from './webhook';
 import { agentCommand } from './agent';
 import envCommand from './env';
 import apikeyCommand from './apikey';
+import { aigatewayCommand } from './aigateway';
 import oidcCommand from './oidc';
 import streamCommand from './stream';
 import vectorCommand from './vector';
@@ -41,6 +42,7 @@ export const command = createCommand({
 	],
 	subcommands: [
 		apikeyCommand,
+		aigatewayCommand,
 		oidcCommand,
 		keyvalueCommand,
 		queueCommand,

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

@@ -3,7 +3,7 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createSandboxClient, parseFileArgs, cacheSandboxTarget } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxCreate } from '@agentuity/server';
+import { sandboxCreate, sandboxGet } from '@agentuity/server';
 import { StructuredError } from '@agentuity/core';
 import { validateAptDependencies } from '../../../utils/apt-validator';
 import { ErrorCode } from '../../../errors';
@@ -13,6 +13,11 @@ const InvalidMetadataError = StructuredError(
 	'Metadata must be a valid JSON object'
 );
 
+const CREATE_WAIT_POLL_MS = 1000;
+const CREATE_WAIT_STATUSES = ['idle', 'running', 'failed', 'terminated', 'deleted'];
+const CREATE_READY_STATUSES = new Set(['idle', 'running']);
+const CREATE_TERMINAL_STATUSES = new Set(['failed', 'terminated', 'deleted']);
+
 const SandboxCreateResponseSchema = z.object({
 	sandboxId: z.string().describe('Unique sandbox identifier'),
 	status: z.string().describe('Current sandbox status'),
@@ -101,6 +106,14 @@ export const createSubcommand = createCommand({
 				.optional()
 				.describe('Port to expose from the sandbox to the outside Internet (1024-65535)'),
 			projectId: z.string().optional().describe('Project ID to associate this sandbox with'),
+			wait: z.boolean().optional().describe('Wait until the sandbox is ready before returning'),
+			waitMs: z
+				.number()
+				.int()
+				.nonnegative()
+				.max(60000)
+				.optional()
+				.describe('Maximum time in milliseconds to wait when --wait is used'),
 		}),
 		response: SandboxCreateResponseSchema,
 	},
@@ -180,7 +193,7 @@ export const createSubcommand = createCommand({
 			metadata = parsed as Record<string, unknown>;
 		}
 
-		const result = await sandboxCreate(client, {
+		let result = await sandboxCreate(client, {
 			options: {
 				projectId,
 				runtime: opts.runtime,
@@ -216,8 +229,48 @@ export const createSubcommand = createCommand({
 			orgId,
 		});
 
-		// Cache routing context for future sandbox commands.
-		await cacheSandboxTarget(config?.name, result.sandboxId, region, orgId);
+		if (opts.wait) {
+			const waitMs = opts.waitMs ?? 60000;
+			const deadline = Date.now() + waitMs;
+
+			while (
+				!CREATE_READY_STATUSES.has(result.status) &&
+				!CREATE_TERMINAL_STATUSES.has(result.status)
+			) {
+				const remainingMs = Math.max(0, deadline - Date.now());
+				if (remainingMs === 0) {
+					break;
+				}
+				const pollWaitMs = Math.min(remainingMs, CREATE_WAIT_POLL_MS);
+				const current = await sandboxGet(client, {
+					sandboxId: result.sandboxId,
+					orgId,
+					includeDeleted: true,
+					waitForStatus: CREATE_WAIT_STATUSES,
+					waitMs: pollWaitMs,
+				});
+
+				result = {
+					...result,
+					status: current.status === 'deleted' ? 'terminated' : current.status,
+				};
+
+				if (
+					CREATE_READY_STATUSES.has(current.status) ||
+					CREATE_TERMINAL_STATUSES.has(current.status)
+				) {
+					break;
+				}
+			}
+		}
+
+		if (
+			CREATE_READY_STATUSES.has(result.status) &&
+			!CREATE_TERMINAL_STATUSES.has(result.status)
+		) {
+			// Cache routing context for future sandbox commands.
+			await cacheSandboxTarget(config?.name, result.sandboxId, region, orgId);
+		}
 
 		if (!options.json) {
 			const duration = Date.now() - started;

package/src/cmd/cloud/sandbox/exec.ts

@@ -101,6 +101,7 @@ export const execSubcommand = createCommand({
 		// Detect if stdout/stderr are redirected to /dev/null
 		const stdoutIsNull = detectNullStream(1);
 		const stderrIsNull = detectNullStream(2);
+		const quiet = opts.quiet || options.quiet;
 
 		// Build stream configuration
 		const streamConfig: {
@@ -112,7 +113,7 @@ export const execSubcommand = createCommand({
 		};
 
 		// --quiet: suppress all output streams (no server streams, no local capture)
-		if (opts.quiet) {
+		if (quiet) {
 			streamConfig.stdout = 'ignore';
 			streamConfig.stderr = 'ignore';
 		} else if (!options.json) {
@@ -177,14 +178,14 @@ export const execSubcommand = createCommand({
 			const stderrChunks: string[] = [];
 
 			const stdoutWritable: NodeJS.WritableStream =
-				options.json || stdoutIsNull
+				options.json || quiet || stdoutIsNull
 					? createCaptureStream((chunk) => {
 							stdoutChunks.push(chunk);
 							outputChunks.push(chunk);
 						})
 					: process.stdout;
 			const stderrWritable: NodeJS.WritableStream =
-				options.json || stderrIsNull
+				options.json || quiet || stderrIsNull
 					? createCaptureStream((chunk) => {
 							stderrChunks.push(chunk);
 							outputChunks.push(chunk);

package/src/cmd/cloud/sandbox/run.ts

@@ -157,6 +157,7 @@ export const runSubcommand = createCommand({
 		// Detect if stdout/stderr are redirected to /dev/null
 		const stdoutIsNull = detectNullStream(1);
 		const stderrIsNull = detectNullStream(2);
+		const quiet = opts.quiet || options.quiet;
 
 		// Detect stream configuration based on TTY status and flags
 		const streamConfig: {
@@ -171,7 +172,7 @@ export const runSubcommand = createCommand({
 		};
 
 		// --quiet: suppress all output streams (no server streams, no local capture)
-		if (opts.quiet) {
+		if (quiet) {
 			streamConfig.stdout = 'ignore';
 			streamConfig.stderr = 'ignore';
 		} else if (!options.json) {
@@ -187,11 +188,11 @@ export const runSubcommand = createCommand({
 
 		// For JSON output or quiet mode, we need to capture output instead of streaming to process
 		const stdout =
-			options.json || opts.quiet || stdoutIsNull
+			options.json || quiet || stdoutIsNull
 				? createCaptureStream((chunk) => outputChunks.push(chunk))
 				: process.stdout;
 		const stderr =
-			options.json || opts.quiet || stderrIsNull
+			options.json || quiet || stderrIsNull
 				? createCaptureStream((chunk) => outputChunks.push(chunk))
 				: process.stderr;
 
@@ -233,8 +234,11 @@ export const runSubcommand = createCommand({
 				logger,
 			});
 
-			// Cache routing context for follow-up lookup/debug flows during execution.
-			await cacheSandboxTarget(config?.name, result.sandboxId, region, orgId);
+			// Best-effort bookkeeping only. One-shot sandboxes are already done by
+			// this point, so don't keep the user waiting on local cache I/O.
+			void cacheSandboxTarget(config?.name, result.sandboxId, region, orgId).catch((err) => {
+				logger.debug('[run] failed to cache sandbox target: %s', err);
+			});
 
 			const duration = Date.now() - started;
 			const output = outputChunks.join('');

package/src/cmd/coder/skill/create.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { CoderClient } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+async function readSkillContent(input: {
+	content?: string;
+	contentFile?: string;
+}): Promise<string> {
+	if (input.content !== undefined && input.contentFile) {
+		throw new Error('Use either --content or --content-file, not both.');
+	}
+	if (input.content !== undefined) return input.content;
+	if (!input.contentFile) {
+		throw new Error('Provide --content or --content-file.');
+	}
+	try {
+		return await Bun.file(input.contentFile).text();
+	} catch (error) {
+		throw new Error(
+			`Failed to read content file "${input.contentFile}": ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+			{ cause: error }
+		);
+	}
+}
+
+export const createCustomSkillSubcommand = createSubcommand({
+	name: 'create',
+	aliases: ['new'],
+	description: 'Create a custom SKILL.md-backed skill',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand(
+				'coder skill create --skill-id release-checklist --name "Release checklist" --content-file ./SKILL.md'
+			),
+			description: 'Create a custom skill from a SKILL.md file',
+		},
+		{
+			command: getCommand(
+				'coder skill create --skill-id release-checklist --name "Release checklist" --content "# Release checklist" --json'
+			),
+			description: 'Create a custom skill from inline content and return JSON',
+		},
+	],
+	schema: {
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+			skillId: z.string().describe('Skill identifier'),
+			name: z.string().describe('Skill name'),
+			description: z.string().optional().describe('Skill description'),
+			content: z.string().optional().describe('Inline SKILL.md content'),
+			contentFile: z.string().optional().describe('Path to a SKILL.md file'),
+		}),
+	},
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		let content: string;
+		try {
+			content = await readSkillContent({
+				content: opts?.content,
+				contentFile: opts?.contentFile,
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to create custom skill: ${msg}`, ErrorCode.VALIDATION_FAILED);
+			return;
+		}
+
+		if (!content.trim()) {
+			tui.fatal(
+				'Failed to create custom skill: SKILL.md content cannot be empty.',
+				ErrorCode.VALIDATION_FAILED
+			);
+			return;
+		}
+
+		try {
+			const saved = await client.createCustomSkill({
+				skillId: opts.skillId,
+				name: opts.name,
+				...(opts?.description !== undefined ? { description: opts.description } : {}),
+				content,
+			});
+
+			if (options.json) {
+				return saved;
+			}
+
+			tui.success(`Custom skill ${saved.id} created.`);
+			tui.newline();
+			tui.output(`  Name:     ${tui.bold(saved.name)}`);
+			tui.output(`  Skill ID: ${saved.skillId}`);
+			tui.output(`  Source:   ${saved.source}`);
+			if (saved.description) {
+				tui.output(`  Desc:     ${saved.description}`);
+			}
+
+			return saved;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+				tui.fatal(`Failed to create custom skill: ${err.message}`, ErrorCode.VALIDATION_FAILED);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to create custom skill: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/skill/index.ts

@@ -1,5 +1,6 @@
 import { createCommand } from '../../../types';
 import { listSubcommand } from './list';
+import { createCustomSkillSubcommand } from './create';
 import { saveSkillSubcommand } from './save';
 import { deleteSkillSubcommand } from './delete';
 import { bucketsSubcommand } from './buckets';
@@ -16,6 +17,12 @@ export const skillCommand = createCommand({
 			command: getCommand('coder skill list'),
 			description: 'List saved skills',
 		},
+		{
+			command: getCommand(
+				'coder skill create --skill-id release-checklist --name "Release checklist" --content-file ./SKILL.md'
+			),
+			description: 'Create a custom skill',
+		},
 		{
 			command: getCommand(
 				'coder skill save --repo org/repo --skill-id sk_abc --name "My Skill"'
@@ -31,5 +38,11 @@ export const skillCommand = createCommand({
 			description: 'List skill buckets',
 		},
 	],
-	subcommands: [listSubcommand, saveSkillSubcommand, deleteSkillSubcommand, bucketsSubcommand],
+	subcommands: [
+		listSubcommand,
+		createCustomSkillSubcommand,
+		saveSkillSubcommand,
+		deleteSkillSubcommand,
+		bucketsSubcommand,
+	],
 });

package/src/cmd/coder/start.ts

@@ -391,6 +391,7 @@ export const startSubcommand = createSubcommand({
 		};
 		env.AGENTUITY_CODER_API_KEY = ctx.auth.apiKey;
 		env.AGENTUITY_ORGID = ctx.orgId;
+		env.PI_SKIP_VERSION_CHECK = '1';
 
 		if (opts?.agent) {
 			env.AGENTUITY_CODER_AGENT = opts.agent;