@agentuity/cli 2.0.14 → 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/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/workspace/common.ts

@@ -2,16 +2,32 @@ import {
 	type CoderCreateWorkspaceRequest,
 	type CoderUpdateWorkspaceRequest,
 	type CoderWorkspaceDetail,
+	type CoderWorkspaceSystemPromptMode,
 } from '@agentuity/core/coder';
 import { StructuredError } from '@agentuity/core';
 import * as tui from '../../../tui';
 
 export const EMPTY_WORKSPACE_ERROR =
-	'A workspace needs at least one repo, dependency, setup script, saved skill, skill bucket, or agent';
+	'A workspace needs at least one repo, dependency, setup script, system prompt, saved skill, skill bucket, or agent';
 export const SetupScriptValidationError = StructuredError('SetupScriptValidationError')<{
 	message: string;
 	path?: string;
 }>();
+export const SystemPromptValidationError = StructuredError('SystemPromptValidationError')<{
+	message: string;
+	path?: string;
+}>();
+
+export function normalizeSystemPromptMode(
+	value?: string
+): CoderWorkspaceSystemPromptMode | undefined {
+	if (value === undefined) return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === 'append' || normalized === 'overwrite') return normalized;
+	throw new SystemPromptValidationError({
+		message: 'Use --system-prompt-mode append or --system-prompt-mode overwrite.',
+	});
+}
 
 export function parseCommaList(value?: string): string[] {
 	return value
@@ -46,11 +62,36 @@ export async function readSetupScript(input: {
 	}
 }
 
+export async function readSystemPrompt(input: {
+	systemPrompt?: string;
+	systemPromptFile?: string;
+}): Promise<string | undefined> {
+	if (input.systemPrompt !== undefined && input.systemPromptFile) {
+		throw new SystemPromptValidationError({
+			message: 'Use either --system-prompt or --system-prompt-file, not both.',
+		});
+	}
+	if (input.systemPrompt !== undefined) return input.systemPrompt;
+	if (!input.systemPromptFile) return undefined;
+	try {
+		return await Bun.file(input.systemPromptFile).text();
+	} catch (error) {
+		throw new SystemPromptValidationError({
+			message: `Failed to read system prompt file "${input.systemPromptFile}": ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+			path: input.systemPromptFile,
+			cause: error,
+		});
+	}
+}
+
 export function hasWorkspaceSelections(input: CoderCreateWorkspaceRequest): boolean {
 	return (
 		(input.repos?.length ?? 0) > 0 ||
 		(input.dependencies?.length ?? 0) > 0 ||
 		Boolean(input.setupScript?.trim()) ||
+		Boolean(input.systemPrompt?.trim()) ||
 		(input.savedSkillIds?.length ?? 0) > 0 ||
 		(input.skillBucketIds?.length ?? 0) > 0 ||
 		(input.enabledAgents?.length ?? 0) > 0
@@ -67,7 +108,7 @@ export function formatWorkspaceValidationMessage(issues: Array<{ message: string
 		return 'Invalid workspace configuration';
 	}
 	if (messages.includes(EMPTY_WORKSPACE_ERROR)) {
-		return `${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, or --enabled-agents.`;
+		return `${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, --system-prompt, or --enabled-agents.`;
 	}
 	return messages.join('; ');
 }
@@ -94,6 +135,9 @@ export function printWorkspaceSummary(workspace: CoderWorkspaceDetail): void {
 	if (workspace.setupScript) {
 		tui.output('  Setup:       configured');
 	}
+	if (workspace.systemPrompt) {
+		tui.output(`  Prompt:      configured (${workspace.systemPromptMode})`);
+	}
 	if (workspace.snapshot?.status) {
 		tui.output(`  Snapshot:    ${workspace.snapshot.status}`);
 	}

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

@@ -14,8 +14,10 @@ import {
 	EMPTY_WORKSPACE_ERROR,
 	formatWorkspaceValidationMessage,
 	hasWorkspaceSelections,
+	normalizeSystemPromptMode,
 	parseCommaList,
 	printWorkspaceSummary,
+	readSystemPrompt,
 	readSetupScript,
 } from './common';
 
@@ -38,6 +40,12 @@ export const createWorkspaceSubcommand = createSubcommand({
 			),
 			description: 'Create an org-scoped workspace with dependencies and a setup script',
 		},
+		{
+			command: getCommand(
+				'coder workspace create "My Workspace" --system-prompt-file ./WORKSPACE_PROMPT.md --system-prompt-mode overwrite'
+			),
+			description: 'Create a workspace with Lead system prompt instructions',
+		},
 		{
 			command: getCommand('coder workspace create "My Workspace" --enabled-agents code-review'),
 			description: 'Create a workspace with an agent roster',
@@ -71,6 +79,18 @@ export const createWorkspaceSubcommand = createSubcommand({
 				.string()
 				.optional()
 				.describe('Path to a shell script to run while preparing workspace snapshots'),
+			systemPrompt: z
+				.string()
+				.optional()
+				.describe('Inline Lead system prompt to apply to sessions created from this workspace'),
+			systemPromptFile: z
+				.string()
+				.optional()
+				.describe('Path to a file containing the workspace Lead system prompt'),
+			systemPromptMode: z
+				.string()
+				.optional()
+				.describe('How to apply the system prompt: append or overwrite'),
 			enabledAgents: z
 				.string()
 				.optional()
@@ -116,12 +136,25 @@ export const createWorkspaceSubcommand = createSubcommand({
 			tui.fatal(`Failed to read setup script: ${msg}`, ErrorCode.VALIDATION_FAILED);
 			return;
 		}
+		try {
+			const systemPrompt = await readSystemPrompt({
+				systemPrompt: opts?.systemPrompt,
+				systemPromptFile: opts?.systemPromptFile,
+			});
+			if (systemPrompt !== undefined) body.systemPrompt = systemPrompt;
+			const systemPromptMode = normalizeSystemPromptMode(opts?.systemPromptMode);
+			if (systemPromptMode !== undefined) body.systemPromptMode = systemPromptMode;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to read system prompt: ${msg}`, ErrorCode.VALIDATION_FAILED);
+			return;
+		}
 		if (opts?.enabledAgents) {
 			body.enabledAgents = parseCommaList(opts.enabledAgents);
 		}
 		if (!hasWorkspaceSelections(body)) {
 			tui.fatal(
-				`Failed to create workspace: ${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, or --enabled-agents.`,
+				`Failed to create workspace: ${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, --system-prompt, or --enabled-agents.`,
 				ErrorCode.VALIDATION_FAILED
 			);
 		}

package/src/cmd/coder/workspace/update.ts

@@ -13,8 +13,10 @@ import { resolveGitHubRepo } from '../resolve-repo';
 import {
 	formatWorkspaceValidationMessage,
 	hasWorkspaceUpdate,
+	normalizeSystemPromptMode,
 	parseCommaList,
 	printWorkspaceSummary,
+	readSystemPrompt,
 	readSetupScript,
 } from './common';
 
@@ -33,6 +35,12 @@ export const updateWorkspaceSubcommand = createSubcommand({
 			command: getCommand('coder workspace update ws_abc123 --setup-script-file ./setup.sh'),
 			description: 'Update the workspace setup script',
 		},
+		{
+			command: getCommand(
+				'coder workspace update ws_abc123 --system-prompt-file ./WORKSPACE_PROMPT.md --system-prompt-mode append'
+			),
+			description: 'Update the workspace Lead system prompt',
+		},
 	],
 	schema: {
 		args: z.object({
@@ -57,6 +65,18 @@ export const updateWorkspaceSubcommand = createSubcommand({
 				.string()
 				.optional()
 				.describe('Path to a shell script to run while preparing workspace snapshots'),
+			systemPrompt: z
+				.string()
+				.optional()
+				.describe('Inline Lead system prompt to apply to sessions created from this workspace'),
+			systemPromptFile: z
+				.string()
+				.optional()
+				.describe('Path to a file containing the workspace Lead system prompt'),
+			systemPromptMode: z
+				.string()
+				.optional()
+				.describe('How to apply the system prompt: append or overwrite'),
 			enabledAgents: z
 				.string()
 				.optional()
@@ -102,6 +122,19 @@ export const updateWorkspaceSubcommand = createSubcommand({
 			tui.fatal(`Failed to read setup script: ${msg}`, ErrorCode.VALIDATION_FAILED);
 			return;
 		}
+		try {
+			const systemPrompt = await readSystemPrompt({
+				systemPrompt: opts?.systemPrompt,
+				systemPromptFile: opts?.systemPromptFile,
+			});
+			if (systemPrompt !== undefined) body.systemPrompt = systemPrompt;
+			const systemPromptMode = normalizeSystemPromptMode(opts?.systemPromptMode);
+			if (systemPromptMode !== undefined) body.systemPromptMode = systemPromptMode;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to read system prompt: ${msg}`, ErrorCode.VALIDATION_FAILED);
+			return;
+		}
 		if (opts?.enabledAgents) {
 			body.enabledAgents = parseCommaList(opts.enabledAgents);
 		}